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_users_dump(self):
918 """ NAT44ED API test - nat44_user_dump """
920 self.nat_add_address(self.nat_addr)
921 self.nat_add_inside_interface(self.pg0)
922 self.nat_add_outside_interface(self.pg1)
924 self.vapi.nat44_forwarding_enable_disable(enable=1)
926 local_ip = self.pg0.remote_ip4
927 external_ip = self.nat_addr
928 self.nat_add_static_mapping(local_ip, external_ip)
930 users = self.vapi.nat44_user_dump()
931 self.assertEqual(len(users), 0)
933 # in2out - static mapping match
935 pkts = self.create_stream_out(self.pg1)
936 self.pg1.add_stream(pkts)
937 self.pg_enable_capture(self.pg_interfaces)
939 capture = self.pg0.get_capture(len(pkts))
940 self.verify_capture_in(capture, self.pg0)
942 pkts = self.create_stream_in(self.pg0, self.pg1)
943 self.pg0.add_stream(pkts)
944 self.pg_enable_capture(self.pg_interfaces)
946 capture = self.pg1.get_capture(len(pkts))
947 self.verify_capture_out(capture, same_port=True)
949 users = self.vapi.nat44_user_dump()
950 self.assertEqual(len(users), 1)
951 static_user = users[0]
952 self.assertEqual(static_user.nstaticsessions, 3)
953 self.assertEqual(static_user.nsessions, 0)
955 # in2out - no static mapping match (forwarding test)
957 host0 = self.pg0.remote_hosts[0]
958 self.pg0.remote_hosts[0] = self.pg0.remote_hosts[1]
960 pkts = self.create_stream_out(self.pg1,
961 dst_ip=self.pg0.remote_ip4,
962 use_inside_ports=True)
963 self.pg1.add_stream(pkts)
964 self.pg_enable_capture(self.pg_interfaces)
966 capture = self.pg0.get_capture(len(pkts))
967 self.verify_capture_in(capture, self.pg0)
969 pkts = self.create_stream_in(self.pg0, self.pg1)
970 self.pg0.add_stream(pkts)
971 self.pg_enable_capture(self.pg_interfaces)
973 capture = self.pg1.get_capture(len(pkts))
974 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
977 self.pg0.remote_hosts[0] = host0
979 users = self.vapi.nat44_user_dump()
980 self.assertEqual(len(users), 2)
981 if str(users[0].ip_address) == self.pg0.remote_hosts[0].ip4:
982 non_static_user = users[1]
983 static_user = users[0]
985 non_static_user = users[0]
986 static_user = users[1]
987 self.assertEqual(static_user.nstaticsessions, 3)
988 self.assertEqual(static_user.nsessions, 0)
989 self.assertEqual(non_static_user.nstaticsessions, 0)
990 self.assertEqual(non_static_user.nsessions, 3)
992 users = self.vapi.nat44_user_dump()
993 self.assertEqual(len(users), 2)
994 if str(users[0].ip_address) == self.pg0.remote_hosts[0].ip4:
995 non_static_user = users[1]
996 static_user = users[0]
998 non_static_user = users[0]
999 static_user = users[1]
1000 self.assertEqual(static_user.nstaticsessions, 3)
1001 self.assertEqual(static_user.nsessions, 0)
1002 self.assertEqual(non_static_user.nstaticsessions, 0)
1003 self.assertEqual(non_static_user.nsessions, 3)
1005 def test_frag_out_of_order_do_not_translate(self):
1006 """ NAT44ED don't translate fragments arriving out of order """
1007 self.nat_add_inside_interface(self.pg0)
1008 self.nat_add_outside_interface(self.pg1)
1009 self.vapi.nat44_forwarding_enable_disable(enable=True)
1010 self.frag_out_of_order(proto=IP_PROTOS.tcp, dont_translate=True)
1012 def test_forwarding(self):
1013 """ NAT44ED forwarding test """
1015 self.nat_add_inside_interface(self.pg0)
1016 self.nat_add_outside_interface(self.pg1)
1017 self.vapi.nat44_forwarding_enable_disable(enable=1)
1019 real_ip = self.pg0.remote_ip4
1020 alias_ip = self.nat_addr
1021 flags = self.config_flags.NAT_IS_ADDR_ONLY
1022 self.vapi.nat44_add_del_static_mapping(is_add=1,
1023 local_ip_address=real_ip,
1024 external_ip_address=alias_ip,
1025 external_sw_if_index=0xFFFFFFFF,
1029 # in2out - static mapping match
1031 pkts = self.create_stream_out(self.pg1)
1032 self.pg1.add_stream(pkts)
1033 self.pg_enable_capture(self.pg_interfaces)
1035 capture = self.pg0.get_capture(len(pkts))
1036 self.verify_capture_in(capture, self.pg0)
1038 pkts = self.create_stream_in(self.pg0, self.pg1)
1039 self.pg0.add_stream(pkts)
1040 self.pg_enable_capture(self.pg_interfaces)
1042 capture = self.pg1.get_capture(len(pkts))
1043 self.verify_capture_out(capture, same_port=True)
1045 # in2out - no static mapping match
1047 host0 = self.pg0.remote_hosts[0]
1048 self.pg0.remote_hosts[0] = self.pg0.remote_hosts[1]
1050 pkts = self.create_stream_out(self.pg1,
1051 dst_ip=self.pg0.remote_ip4,
1052 use_inside_ports=True)
1053 self.pg1.add_stream(pkts)
1054 self.pg_enable_capture(self.pg_interfaces)
1056 capture = self.pg0.get_capture(len(pkts))
1057 self.verify_capture_in(capture, self.pg0)
1059 pkts = self.create_stream_in(self.pg0, self.pg1)
1060 self.pg0.add_stream(pkts)
1061 self.pg_enable_capture(self.pg_interfaces)
1063 capture = self.pg1.get_capture(len(pkts))
1064 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
1067 self.pg0.remote_hosts[0] = host0
1069 user = self.pg0.remote_hosts[1]
1070 sessions = self.vapi.nat44_user_session_dump(user.ip4, 0)
1071 self.assertEqual(len(sessions), 3)
1072 self.assertTrue(sessions[0].flags &
1073 self.config_flags.NAT_IS_EXT_HOST_VALID)
1074 self.vapi.nat44_del_session(
1075 address=sessions[0].inside_ip_address,
1076 port=sessions[0].inside_port,
1077 protocol=sessions[0].protocol,
1078 flags=(self.config_flags.NAT_IS_INSIDE |
1079 self.config_flags.NAT_IS_EXT_HOST_VALID),
1080 ext_host_address=sessions[0].ext_host_address,
1081 ext_host_port=sessions[0].ext_host_port)
1082 sessions = self.vapi.nat44_user_session_dump(user.ip4, 0)
1083 self.assertEqual(len(sessions), 2)
1086 self.vapi.nat44_forwarding_enable_disable(enable=0)
1087 flags = self.config_flags.NAT_IS_ADDR_ONLY
1088 self.vapi.nat44_add_del_static_mapping(
1090 local_ip_address=real_ip,
1091 external_ip_address=alias_ip,
1092 external_sw_if_index=0xFFFFFFFF,
1095 def test_output_feature_and_service2(self):
1096 """ NAT44ED interface output feature and service host direct access """
1097 self.vapi.nat44_forwarding_enable_disable(enable=1)
1098 self.nat_add_address(self.nat_addr)
1100 self.vapi.nat44_interface_add_del_output_feature(
1101 sw_if_index=self.pg1.sw_if_index, is_add=1,)
1103 # session initiated from service host - translate
1104 pkts = self.create_stream_in(self.pg0, self.pg1)
1105 self.pg0.add_stream(pkts)
1106 self.pg_enable_capture(self.pg_interfaces)
1108 capture = self.pg1.get_capture(len(pkts))
1109 self.verify_capture_out(capture, ignore_port=True)
1111 pkts = self.create_stream_out(self.pg1)
1112 self.pg1.add_stream(pkts)
1113 self.pg_enable_capture(self.pg_interfaces)
1115 capture = self.pg0.get_capture(len(pkts))
1116 self.verify_capture_in(capture, self.pg0)
1118 # session initiated from remote host - do not translate
1119 tcp_port_in = self.tcp_port_in
1120 udp_port_in = self.udp_port_in
1121 icmp_id_in = self.icmp_id_in
1123 self.tcp_port_in = 60303
1124 self.udp_port_in = 60304
1125 self.icmp_id_in = 60305
1128 pkts = self.create_stream_out(self.pg1,
1129 self.pg0.remote_ip4,
1130 use_inside_ports=True)
1131 self.pg1.add_stream(pkts)
1132 self.pg_enable_capture(self.pg_interfaces)
1134 capture = self.pg0.get_capture(len(pkts))
1135 self.verify_capture_in(capture, self.pg0)
1137 pkts = self.create_stream_in(self.pg0, self.pg1)
1138 self.pg0.add_stream(pkts)
1139 self.pg_enable_capture(self.pg_interfaces)
1141 capture = self.pg1.get_capture(len(pkts))
1142 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
1145 self.tcp_port_in = tcp_port_in
1146 self.udp_port_in = udp_port_in
1147 self.icmp_id_in = icmp_id_in
1149 def test_twice_nat(self):
1150 """ NAT44ED Twice NAT """
1151 self.twice_nat_common()
1153 def test_self_twice_nat_positive(self):
1154 """ NAT44ED Self Twice NAT (positive test) """
1155 self.twice_nat_common(self_twice_nat=True, same_pg=True)
1157 def test_self_twice_nat_lb_positive(self):
1158 """ NAT44ED Self Twice NAT local service load balancing (positive test)
1160 self.twice_nat_common(lb=True, self_twice_nat=True, same_pg=True,
1163 def test_twice_nat_lb(self):
1164 """ NAT44ED Twice NAT local service load balancing """
1165 self.twice_nat_common(lb=True)
1167 def test_output_feature(self):
1168 """ NAT44ED interface output feature (in2out postrouting) """
1169 self.vapi.nat44_forwarding_enable_disable(enable=1)
1170 self.nat_add_address(self.nat_addr)
1172 self.nat_add_outside_interface(self.pg0)
1173 self.vapi.nat44_interface_add_del_output_feature(
1174 sw_if_index=self.pg1.sw_if_index, is_add=1)
1177 pkts = self.create_stream_in(self.pg0, self.pg1)
1178 self.pg0.add_stream(pkts)
1179 self.pg_enable_capture(self.pg_interfaces)
1181 capture = self.pg1.get_capture(len(pkts))
1182 self.verify_capture_out(capture, ignore_port=True)
1185 pkts = self.create_stream_out(self.pg1)
1186 self.pg1.add_stream(pkts)
1187 self.pg_enable_capture(self.pg_interfaces)
1189 capture = self.pg0.get_capture(len(pkts))
1190 self.verify_capture_in(capture, self.pg0)
1192 def test_static_with_port_out2(self):
1193 """ NAT44ED 1:1 NAPT asymmetrical rule """
1198 self.vapi.nat44_forwarding_enable_disable(enable=1)
1199 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1200 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
1201 local_port, external_port,
1202 proto=IP_PROTOS.tcp, flags=flags)
1204 self.nat_add_inside_interface(self.pg0)
1205 self.nat_add_outside_interface(self.pg1)
1207 # from client to service
1208 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1209 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1210 TCP(sport=12345, dport=external_port))
1211 self.pg1.add_stream(p)
1212 self.pg_enable_capture(self.pg_interfaces)
1214 capture = self.pg0.get_capture(1)
1219 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1220 self.assertEqual(tcp.dport, local_port)
1221 self.assert_packet_checksums_valid(p)
1223 self.logger.error(ppp("Unexpected or invalid packet:", p))
1227 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
1228 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1229 ICMP(type=11) / capture[0][IP])
1230 self.pg0.add_stream(p)
1231 self.pg_enable_capture(self.pg_interfaces)
1233 capture = self.pg1.get_capture(1)
1236 self.assertEqual(p[IP].src, self.nat_addr)
1238 self.assertEqual(inner.dst, self.nat_addr)
1239 self.assertEqual(inner[TCPerror].dport, external_port)
1241 self.logger.error(ppp("Unexpected or invalid packet:", p))
1244 # from service back to client
1245 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1246 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1247 TCP(sport=local_port, dport=12345))
1248 self.pg0.add_stream(p)
1249 self.pg_enable_capture(self.pg_interfaces)
1251 capture = self.pg1.get_capture(1)
1256 self.assertEqual(ip.src, self.nat_addr)
1257 self.assertEqual(tcp.sport, external_port)
1258 self.assert_packet_checksums_valid(p)
1260 self.logger.error(ppp("Unexpected or invalid packet:", p))
1264 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1265 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1266 ICMP(type=11) / capture[0][IP])
1267 self.pg1.add_stream(p)
1268 self.pg_enable_capture(self.pg_interfaces)
1270 capture = self.pg0.get_capture(1)
1273 self.assertEqual(p[IP].dst, self.pg0.remote_ip4)
1275 self.assertEqual(inner.src, self.pg0.remote_ip4)
1276 self.assertEqual(inner[TCPerror].sport, local_port)
1278 self.logger.error(ppp("Unexpected or invalid packet:", p))
1281 # from client to server (no translation)
1282 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1283 IP(src=self.pg1.remote_ip4, dst=self.pg0.remote_ip4) /
1284 TCP(sport=12346, dport=local_port))
1285 self.pg1.add_stream(p)
1286 self.pg_enable_capture(self.pg_interfaces)
1288 capture = self.pg0.get_capture(1)
1293 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1294 self.assertEqual(tcp.dport, local_port)
1295 self.assert_packet_checksums_valid(p)
1297 self.logger.error(ppp("Unexpected or invalid packet:", p))
1300 # from service back to client (no translation)
1301 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1302 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1303 TCP(sport=local_port, dport=12346))
1304 self.pg0.add_stream(p)
1305 self.pg_enable_capture(self.pg_interfaces)
1307 capture = self.pg1.get_capture(1)
1312 self.assertEqual(ip.src, self.pg0.remote_ip4)
1313 self.assertEqual(tcp.sport, local_port)
1314 self.assert_packet_checksums_valid(p)
1316 self.logger.error(ppp("Unexpected or invalid packet:", p))
1319 def test_static_lb(self):
1320 """ NAT44ED local service load balancing """
1321 external_addr_n = self.nat_addr
1324 server1 = self.pg0.remote_hosts[0]
1325 server2 = self.pg0.remote_hosts[1]
1327 locals = [{'addr': server1.ip4,
1331 {'addr': server2.ip4,
1336 self.nat_add_address(self.nat_addr)
1337 self.vapi.nat44_add_del_lb_static_mapping(
1339 external_addr=external_addr_n,
1340 external_port=external_port,
1341 protocol=IP_PROTOS.tcp,
1342 local_num=len(locals),
1344 flags = self.config_flags.NAT_IS_INSIDE
1345 self.vapi.nat44_interface_add_del_feature(
1346 sw_if_index=self.pg0.sw_if_index,
1347 flags=flags, is_add=1)
1348 self.vapi.nat44_interface_add_del_feature(
1349 sw_if_index=self.pg1.sw_if_index,
1352 # from client to service
1353 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1354 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1355 TCP(sport=12345, dport=external_port))
1356 self.pg1.add_stream(p)
1357 self.pg_enable_capture(self.pg_interfaces)
1359 capture = self.pg0.get_capture(1)
1365 self.assertIn(ip.dst, [server1.ip4, server2.ip4])
1366 if ip.dst == server1.ip4:
1370 self.assertEqual(tcp.dport, local_port)
1371 self.assert_packet_checksums_valid(p)
1373 self.logger.error(ppp("Unexpected or invalid packet:", p))
1376 # from service back to client
1377 p = (Ether(src=server.mac, dst=self.pg0.local_mac) /
1378 IP(src=server.ip4, dst=self.pg1.remote_ip4) /
1379 TCP(sport=local_port, dport=12345))
1380 self.pg0.add_stream(p)
1381 self.pg_enable_capture(self.pg_interfaces)
1383 capture = self.pg1.get_capture(1)
1388 self.assertEqual(ip.src, self.nat_addr)
1389 self.assertEqual(tcp.sport, external_port)
1390 self.assert_packet_checksums_valid(p)
1392 self.logger.error(ppp("Unexpected or invalid packet:", p))
1395 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
1396 self.assertEqual(len(sessions), 1)
1397 self.assertTrue(sessions[0].flags &
1398 self.config_flags.NAT_IS_EXT_HOST_VALID)
1399 self.vapi.nat44_del_session(
1400 address=sessions[0].inside_ip_address,
1401 port=sessions[0].inside_port,
1402 protocol=sessions[0].protocol,
1403 flags=(self.config_flags.NAT_IS_INSIDE |
1404 self.config_flags.NAT_IS_EXT_HOST_VALID),
1405 ext_host_address=sessions[0].ext_host_address,
1406 ext_host_port=sessions[0].ext_host_port)
1407 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
1408 self.assertEqual(len(sessions), 0)
1410 def test_static_lb_2(self):
1411 """ NAT44ED local service load balancing (asymmetrical rule) """
1412 external_addr = self.nat_addr
1415 server1 = self.pg0.remote_hosts[0]
1416 server2 = self.pg0.remote_hosts[1]
1418 locals = [{'addr': server1.ip4,
1422 {'addr': server2.ip4,
1427 self.vapi.nat44_forwarding_enable_disable(enable=1)
1428 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1429 self.vapi.nat44_add_del_lb_static_mapping(is_add=1, flags=flags,
1430 external_addr=external_addr,
1431 external_port=external_port,
1432 protocol=IP_PROTOS.tcp,
1433 local_num=len(locals),
1435 flags = self.config_flags.NAT_IS_INSIDE
1436 self.vapi.nat44_interface_add_del_feature(
1437 sw_if_index=self.pg0.sw_if_index,
1438 flags=flags, is_add=1)
1439 self.vapi.nat44_interface_add_del_feature(
1440 sw_if_index=self.pg1.sw_if_index,
1443 # from client to service
1444 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1445 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1446 TCP(sport=12345, dport=external_port))
1447 self.pg1.add_stream(p)
1448 self.pg_enable_capture(self.pg_interfaces)
1450 capture = self.pg0.get_capture(1)
1456 self.assertIn(ip.dst, [server1.ip4, server2.ip4])
1457 if ip.dst == server1.ip4:
1461 self.assertEqual(tcp.dport, local_port)
1462 self.assert_packet_checksums_valid(p)
1464 self.logger.error(ppp("Unexpected or invalid packet:", p))
1467 # from service back to client
1468 p = (Ether(src=server.mac, dst=self.pg0.local_mac) /
1469 IP(src=server.ip4, dst=self.pg1.remote_ip4) /
1470 TCP(sport=local_port, dport=12345))
1471 self.pg0.add_stream(p)
1472 self.pg_enable_capture(self.pg_interfaces)
1474 capture = self.pg1.get_capture(1)
1479 self.assertEqual(ip.src, self.nat_addr)
1480 self.assertEqual(tcp.sport, external_port)
1481 self.assert_packet_checksums_valid(p)
1483 self.logger.error(ppp("Unexpected or invalid packet:", p))
1486 # from client to server (no translation)
1487 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1488 IP(src=self.pg1.remote_ip4, dst=server1.ip4) /
1489 TCP(sport=12346, dport=local_port))
1490 self.pg1.add_stream(p)
1491 self.pg_enable_capture(self.pg_interfaces)
1493 capture = self.pg0.get_capture(1)
1499 self.assertEqual(ip.dst, server1.ip4)
1500 self.assertEqual(tcp.dport, local_port)
1501 self.assert_packet_checksums_valid(p)
1503 self.logger.error(ppp("Unexpected or invalid packet:", p))
1506 # from service back to client (no translation)
1507 p = (Ether(src=server1.mac, dst=self.pg0.local_mac) /
1508 IP(src=server1.ip4, dst=self.pg1.remote_ip4) /
1509 TCP(sport=local_port, dport=12346))
1510 self.pg0.add_stream(p)
1511 self.pg_enable_capture(self.pg_interfaces)
1513 capture = self.pg1.get_capture(1)
1518 self.assertEqual(ip.src, server1.ip4)
1519 self.assertEqual(tcp.sport, local_port)
1520 self.assert_packet_checksums_valid(p)
1522 self.logger.error(ppp("Unexpected or invalid packet:", p))
1525 def test_lb_affinity(self):
1526 """ NAT44ED local service load balancing affinity """
1527 external_addr = self.nat_addr
1530 server1 = self.pg0.remote_hosts[0]
1531 server2 = self.pg0.remote_hosts[1]
1533 locals = [{'addr': server1.ip4,
1537 {'addr': server2.ip4,
1542 self.nat_add_address(self.nat_addr)
1543 self.vapi.nat44_add_del_lb_static_mapping(is_add=1,
1544 external_addr=external_addr,
1545 external_port=external_port,
1546 protocol=IP_PROTOS.tcp,
1548 local_num=len(locals),
1550 flags = self.config_flags.NAT_IS_INSIDE
1551 self.vapi.nat44_interface_add_del_feature(
1552 sw_if_index=self.pg0.sw_if_index,
1553 flags=flags, is_add=1)
1554 self.vapi.nat44_interface_add_del_feature(
1555 sw_if_index=self.pg1.sw_if_index,
1558 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1559 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1560 TCP(sport=1025, dport=external_port))
1561 self.pg1.add_stream(p)
1562 self.pg_enable_capture(self.pg_interfaces)
1564 capture = self.pg0.get_capture(1)
1565 backend = capture[0][IP].dst
1567 sessions = self.vapi.nat44_user_session_dump(backend, 0)
1568 self.assertEqual(len(sessions), 1)
1569 self.assertTrue(sessions[0].flags &
1570 self.config_flags.NAT_IS_EXT_HOST_VALID)
1571 self.vapi.nat44_del_session(
1572 address=sessions[0].inside_ip_address,
1573 port=sessions[0].inside_port,
1574 protocol=sessions[0].protocol,
1575 flags=(self.config_flags.NAT_IS_INSIDE |
1576 self.config_flags.NAT_IS_EXT_HOST_VALID),
1577 ext_host_address=sessions[0].ext_host_address,
1578 ext_host_port=sessions[0].ext_host_port)
1581 for port in range(1030, 1100):
1582 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1583 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1584 TCP(sport=port, dport=external_port))
1586 self.pg1.add_stream(pkts)
1587 self.pg_enable_capture(self.pg_interfaces)
1589 capture = self.pg0.get_capture(len(pkts))
1591 self.assertEqual(p[IP].dst, backend)
1593 def test_multiple_vrf_1(self):
1594 """ Multiple VRF - both client & service in VRF1 """
1596 external_addr = '1.2.3.4'
1601 flags = self.config_flags.NAT_IS_INSIDE
1602 self.vapi.nat44_interface_add_del_feature(
1603 sw_if_index=self.pg5.sw_if_index,
1605 self.vapi.nat44_interface_add_del_feature(
1606 sw_if_index=self.pg5.sw_if_index,
1607 is_add=1, flags=flags)
1608 self.vapi.nat44_interface_add_del_feature(
1609 sw_if_index=self.pg6.sw_if_index,
1611 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1612 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1613 local_port, external_port, vrf_id=1,
1614 proto=IP_PROTOS.tcp, flags=flags)
1616 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
1617 IP(src=self.pg6.remote_ip4, dst=external_addr) /
1618 TCP(sport=12345, dport=external_port))
1619 self.pg6.add_stream(p)
1620 self.pg_enable_capture(self.pg_interfaces)
1622 capture = self.pg5.get_capture(1)
1627 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1628 self.assertEqual(tcp.dport, local_port)
1629 self.assert_packet_checksums_valid(p)
1631 self.logger.error(ppp("Unexpected or invalid packet:", p))
1634 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1635 IP(src=self.pg5.remote_ip4, dst=self.pg6.remote_ip4) /
1636 TCP(sport=local_port, dport=12345))
1637 self.pg5.add_stream(p)
1638 self.pg_enable_capture(self.pg_interfaces)
1640 capture = self.pg6.get_capture(1)
1645 self.assertEqual(ip.src, external_addr)
1646 self.assertEqual(tcp.sport, external_port)
1647 self.assert_packet_checksums_valid(p)
1649 self.logger.error(ppp("Unexpected or invalid packet:", p))
1652 def test_multiple_vrf_2(self):
1653 """ Multiple VRF - dynamic NAT from VRF1 to VRF0 (output-feature) """
1655 external_addr = '1.2.3.4'
1660 self.nat_add_address(self.nat_addr)
1661 flags = self.config_flags.NAT_IS_INSIDE
1662 self.vapi.nat44_interface_add_del_output_feature(
1663 sw_if_index=self.pg1.sw_if_index,
1665 self.vapi.nat44_interface_add_del_feature(
1666 sw_if_index=self.pg5.sw_if_index,
1668 self.vapi.nat44_interface_add_del_feature(
1669 sw_if_index=self.pg5.sw_if_index,
1670 is_add=1, flags=flags)
1671 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1672 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1673 local_port, external_port, vrf_id=1,
1674 proto=IP_PROTOS.tcp, flags=flags)
1676 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1677 IP(src=self.pg5.remote_ip4, dst=self.pg1.remote_ip4) /
1678 TCP(sport=2345, dport=22))
1679 self.pg5.add_stream(p)
1680 self.pg_enable_capture(self.pg_interfaces)
1682 capture = self.pg1.get_capture(1)
1687 self.assertEqual(ip.src, self.nat_addr)
1688 self.assert_packet_checksums_valid(p)
1691 self.logger.error(ppp("Unexpected or invalid packet:", p))
1694 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1695 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1696 TCP(sport=22, dport=port))
1697 self.pg1.add_stream(p)
1698 self.pg_enable_capture(self.pg_interfaces)
1700 capture = self.pg5.get_capture(1)
1705 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1706 self.assertEqual(tcp.dport, 2345)
1707 self.assert_packet_checksums_valid(p)
1709 self.logger.error(ppp("Unexpected or invalid packet:", p))
1712 def test_multiple_vrf_3(self):
1713 """ Multiple VRF - client in VRF1, service in VRF0 """
1715 external_addr = '1.2.3.4'
1720 flags = self.config_flags.NAT_IS_INSIDE
1721 self.vapi.nat44_interface_add_del_feature(
1722 sw_if_index=self.pg0.sw_if_index,
1724 self.vapi.nat44_interface_add_del_feature(
1725 sw_if_index=self.pg0.sw_if_index,
1726 is_add=1, flags=flags)
1727 self.vapi.nat44_interface_add_del_feature(
1728 sw_if_index=self.pg6.sw_if_index,
1730 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1731 self.nat_add_static_mapping(
1732 self.pg0.remote_ip4,
1733 external_sw_if_index=self.pg0.sw_if_index,
1734 local_port=local_port,
1736 external_port=external_port,
1737 proto=IP_PROTOS.tcp,
1741 # from client VRF1 to service VRF0
1742 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
1743 IP(src=self.pg6.remote_ip4, dst=self.pg0.local_ip4) /
1744 TCP(sport=12346, dport=external_port))
1745 self.pg6.add_stream(p)
1746 self.pg_enable_capture(self.pg_interfaces)
1748 capture = self.pg0.get_capture(1)
1753 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1754 self.assertEqual(tcp.dport, local_port)
1755 self.assert_packet_checksums_valid(p)
1757 self.logger.error(ppp("Unexpected or invalid packet:", p))
1760 # from service VRF0 back to client VRF1
1761 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1762 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
1763 TCP(sport=local_port, dport=12346))
1764 self.pg0.add_stream(p)
1765 self.pg_enable_capture(self.pg_interfaces)
1767 capture = self.pg6.get_capture(1)
1772 self.assertEqual(ip.src, self.pg0.local_ip4)
1773 self.assertEqual(tcp.sport, external_port)
1774 self.assert_packet_checksums_valid(p)
1776 self.logger.error(ppp("Unexpected or invalid packet:", p))
1779 def test_multiple_vrf_4(self):
1780 """ Multiple VRF - client in VRF0, service in VRF1 """
1782 external_addr = '1.2.3.4'
1787 flags = self.config_flags.NAT_IS_INSIDE
1788 self.vapi.nat44_interface_add_del_feature(
1789 sw_if_index=self.pg0.sw_if_index,
1791 self.vapi.nat44_interface_add_del_feature(
1792 sw_if_index=self.pg0.sw_if_index,
1793 is_add=1, flags=flags)
1794 self.vapi.nat44_interface_add_del_feature(
1795 sw_if_index=self.pg5.sw_if_index,
1797 self.vapi.nat44_interface_add_del_feature(
1798 sw_if_index=self.pg5.sw_if_index,
1799 is_add=1, flags=flags)
1800 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1801 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1802 local_port, external_port, vrf_id=1,
1803 proto=IP_PROTOS.tcp, flags=flags)
1805 # from client VRF0 to service VRF1
1806 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1807 IP(src=self.pg0.remote_ip4, dst=external_addr) /
1808 TCP(sport=12347, dport=external_port))
1809 self.pg0.add_stream(p)
1810 self.pg_enable_capture(self.pg_interfaces)
1812 capture = self.pg5.get_capture(1)
1817 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1818 self.assertEqual(tcp.dport, local_port)
1819 self.assert_packet_checksums_valid(p)
1821 self.logger.error(ppp("Unexpected or invalid packet:", p))
1824 # from service VRF1 back to client VRF0
1825 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1826 IP(src=self.pg5.remote_ip4, dst=self.pg0.remote_ip4) /
1827 TCP(sport=local_port, dport=12347))
1828 self.pg5.add_stream(p)
1829 self.pg_enable_capture(self.pg_interfaces)
1831 capture = self.pg0.get_capture(1)
1836 self.assertEqual(ip.src, external_addr)
1837 self.assertEqual(tcp.sport, external_port)
1838 self.assert_packet_checksums_valid(p)
1840 self.logger.error(ppp("Unexpected or invalid packet:", p))
1843 def test_multiple_vrf_5(self):
1844 """ Multiple VRF - forwarding - no translation """
1846 external_addr = '1.2.3.4'
1851 self.vapi.nat44_forwarding_enable_disable(enable=1)
1852 flags = self.config_flags.NAT_IS_INSIDE
1853 self.vapi.nat44_interface_add_del_feature(
1854 sw_if_index=self.pg0.sw_if_index,
1856 self.vapi.nat44_interface_add_del_feature(
1857 sw_if_index=self.pg0.sw_if_index,
1858 is_add=1, flags=flags)
1859 self.vapi.nat44_interface_add_del_feature(
1860 sw_if_index=self.pg5.sw_if_index,
1862 self.vapi.nat44_interface_add_del_feature(
1863 sw_if_index=self.pg5.sw_if_index,
1864 is_add=1, flags=flags)
1865 self.vapi.nat44_interface_add_del_feature(
1866 sw_if_index=self.pg6.sw_if_index,
1868 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1869 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1870 local_port, external_port, vrf_id=1,
1871 proto=IP_PROTOS.tcp, flags=flags)
1872 self.nat_add_static_mapping(
1873 self.pg0.remote_ip4,
1874 external_sw_if_index=self.pg0.sw_if_index,
1875 local_port=local_port,
1877 external_port=external_port,
1878 proto=IP_PROTOS.tcp,
1882 # from client to server (both VRF1, no translation)
1883 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
1884 IP(src=self.pg6.remote_ip4, dst=self.pg5.remote_ip4) /
1885 TCP(sport=12348, dport=local_port))
1886 self.pg6.add_stream(p)
1887 self.pg_enable_capture(self.pg_interfaces)
1889 capture = self.pg5.get_capture(1)
1894 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1895 self.assertEqual(tcp.dport, local_port)
1896 self.assert_packet_checksums_valid(p)
1898 self.logger.error(ppp("Unexpected or invalid packet:", p))
1901 # from server back to client (both VRF1, no translation)
1902 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1903 IP(src=self.pg5.remote_ip4, dst=self.pg6.remote_ip4) /
1904 TCP(sport=local_port, dport=12348))
1905 self.pg5.add_stream(p)
1906 self.pg_enable_capture(self.pg_interfaces)
1908 capture = self.pg6.get_capture(1)
1913 self.assertEqual(ip.src, self.pg5.remote_ip4)
1914 self.assertEqual(tcp.sport, local_port)
1915 self.assert_packet_checksums_valid(p)
1917 self.logger.error(ppp("Unexpected or invalid packet:", p))
1920 # from client VRF1 to server VRF0 (no translation)
1921 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1922 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
1923 TCP(sport=local_port, dport=12349))
1924 self.pg0.add_stream(p)
1925 self.pg_enable_capture(self.pg_interfaces)
1927 capture = self.pg6.get_capture(1)
1932 self.assertEqual(ip.src, self.pg0.remote_ip4)
1933 self.assertEqual(tcp.sport, local_port)
1934 self.assert_packet_checksums_valid(p)
1936 self.logger.error(ppp("Unexpected or invalid packet:", p))
1939 # from server VRF0 back to client VRF1 (no translation)
1940 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1941 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
1942 TCP(sport=local_port, dport=12349))
1943 self.pg0.add_stream(p)
1944 self.pg_enable_capture(self.pg_interfaces)
1946 capture = self.pg6.get_capture(1)
1951 self.assertEqual(ip.src, self.pg0.remote_ip4)
1952 self.assertEqual(tcp.sport, local_port)
1953 self.assert_packet_checksums_valid(p)
1955 self.logger.error(ppp("Unexpected or invalid packet:", p))
1958 # from client VRF0 to server VRF1 (no translation)
1959 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1960 IP(src=self.pg0.remote_ip4, dst=self.pg5.remote_ip4) /
1961 TCP(sport=12344, dport=local_port))
1962 self.pg0.add_stream(p)
1963 self.pg_enable_capture(self.pg_interfaces)
1965 capture = self.pg5.get_capture(1)
1970 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1971 self.assertEqual(tcp.dport, local_port)
1972 self.assert_packet_checksums_valid(p)
1974 self.logger.error(ppp("Unexpected or invalid packet:", p))
1977 # from server VRF1 back to client VRF0 (no translation)
1978 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1979 IP(src=self.pg5.remote_ip4, dst=self.pg0.remote_ip4) /
1980 TCP(sport=local_port, dport=12344))
1981 self.pg5.add_stream(p)
1982 self.pg_enable_capture(self.pg_interfaces)
1984 capture = self.pg0.get_capture(1)
1989 self.assertEqual(ip.src, self.pg5.remote_ip4)
1990 self.assertEqual(tcp.sport, local_port)
1991 self.assert_packet_checksums_valid(p)
1993 self.logger.error(ppp("Unexpected or invalid packet:", p))
1996 def test_outside_address_distribution(self):
1997 """ Outside address distribution based on source address """
2002 for i in range(1, x):
2004 nat_addresses.append(a)
2006 self.nat_add_inside_interface(self.pg0)
2007 self.nat_add_outside_interface(self.pg1)
2009 self.vapi.nat44_add_del_address_range(
2010 first_ip_address=nat_addresses[0],
2011 last_ip_address=nat_addresses[-1],
2012 vrf_id=0xFFFFFFFF, is_add=1, flags=0)
2014 self.pg0.generate_remote_hosts(x)
2018 info = self.create_packet_info(self.pg0, self.pg1)
2019 payload = self.info_to_payload(info)
2020 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2021 IP(src=self.pg0.remote_hosts[i].ip4,
2022 dst=self.pg1.remote_ip4) /
2023 UDP(sport=7000+i, dport=8000+i) /
2028 self.pg0.add_stream(pkts)
2029 self.pg_enable_capture(self.pg_interfaces)
2031 recvd = self.pg1.get_capture(len(pkts))
2032 for p_recvd in recvd:
2033 payload_info = self.payload_to_info(p_recvd[Raw])
2034 packet_index = payload_info.index
2035 info = self._packet_infos[packet_index]
2036 self.assertTrue(info is not None)
2037 self.assertEqual(packet_index, info.index)
2039 packed = socket.inet_aton(p_sent[IP].src)
2040 numeric = struct.unpack("!L", packed)[0]
2041 numeric = socket.htonl(numeric)
2042 a = nat_addresses[(numeric-1) % len(nat_addresses)]
2045 "Invalid packet (src IP %s translated to %s, but expected %s)"
2046 % (p_sent[IP].src, p_recvd[IP].src, a))
2049 class TestNAT44EDMW(TestNAT44ED):
2050 """ NAT44ED MW Test Case """
2051 vpp_worker_count = 4
2054 @unittest.skip('MW fix required')
2055 def test_users_dump(self):
2056 """ NAT44ED API test - nat44_user_dump """
2058 @unittest.skip('MW fix required')
2059 def test_frag_out_of_order_do_not_translate(self):
2060 """ NAT44ED don't translate fragments arriving out of order """
2062 @unittest.skip('MW fix required')
2063 def test_forwarding(self):
2064 """ NAT44ED forwarding test """
2066 @unittest.skip('MW fix required')
2067 def test_twice_nat(self):
2068 """ NAT44ED Twice NAT """
2070 @unittest.skip('MW fix required')
2071 def test_twice_nat_lb(self):
2072 """ NAT44ED Twice NAT local service load balancing """
2074 @unittest.skip('MW fix required')
2075 def test_output_feature(self):
2076 """ NAT44ED interface output feature (in2out postrouting) """
2078 @unittest.skip('MW fix required')
2079 def test_static_with_port_out2(self):
2080 """ NAT44ED 1:1 NAPT asymmetrical rule """
2082 @unittest.skip('MW fix required')
2083 def test_output_feature_and_service2(self):
2084 """ NAT44ED interface output feature and service host direct access """
2086 @unittest.skip('MW fix required')
2087 def test_static_lb(self):
2088 """ NAT44ED local service load balancing """
2090 @unittest.skip('MW fix required')
2091 def test_static_lb_2(self):
2092 """ NAT44ED local service load balancing (asymmetrical rule) """
2094 @unittest.skip('MW fix required')
2095 def test_lb_affinity(self):
2096 """ NAT44ED local service load balancing affinity """
2098 @unittest.skip('MW fix required')
2099 def test_multiple_vrf(self):
2100 """ NAT44ED Multiple VRF setup """
2102 @unittest.skip('MW fix required')
2103 def test_self_twice_nat_positive(self):
2104 """ NAT44ED Self Twice NAT (positive test) """
2106 @unittest.skip('MW fix required')
2107 def test_self_twice_nat_lb_positive(self):
2108 """ NAT44ED Self Twice NAT local service load balancing (positive test)
2111 def test_dynamic(self):
2112 """ NAT44ED dynamic translation test """
2114 tcp_port_offset = 20
2115 udp_port_offset = 20
2118 self.nat_add_address(self.nat_addr)
2119 self.nat_add_inside_interface(self.pg0)
2120 self.nat_add_outside_interface(self.pg1)
2123 tc1 = self.statistics['/nat44-ed/in2out/slowpath/tcp']
2124 uc1 = self.statistics['/nat44-ed/in2out/slowpath/udp']
2125 ic1 = self.statistics['/nat44-ed/in2out/slowpath/icmp']
2126 dc1 = self.statistics['/nat44-ed/in2out/slowpath/drops']
2128 i2o_pkts = [[] for x in range(0, self.vpp_worker_count)]
2130 for i in range(pkt_count):
2131 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2132 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2133 TCP(sport=tcp_port_offset + i, dport=20))
2134 i2o_pkts[p[TCP].sport % self.vpp_worker_count].append(p)
2136 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2137 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2138 UDP(sport=udp_port_offset + i, dport=20))
2139 i2o_pkts[p[UDP].sport % self.vpp_worker_count].append(p)
2141 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2142 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2143 ICMP(id=icmp_id_offset + i, type='echo-request'))
2144 i2o_pkts[p[ICMP].id % self.vpp_worker_count].append(p)
2146 for i in range(0, self.vpp_worker_count):
2147 if len(i2o_pkts[i]) > 0:
2148 self.pg0.add_stream(i2o_pkts[i], worker=i)
2150 self.pg_enable_capture(self.pg_interfaces)
2152 capture = self.pg1.get_capture(pkt_count * 3)
2154 if_idx = self.pg0.sw_if_index
2155 tc2 = self.statistics['/nat44-ed/in2out/slowpath/tcp']
2156 uc2 = self.statistics['/nat44-ed/in2out/slowpath/udp']
2157 ic2 = self.statistics['/nat44-ed/in2out/slowpath/icmp']
2158 dc2 = self.statistics['/nat44-ed/in2out/slowpath/drops']
2161 tc2[:, if_idx].sum() - tc1[:, if_idx].sum(), pkt_count)
2163 uc2[:, if_idx].sum() - uc1[:, if_idx].sum(), pkt_count)
2165 ic2[:, if_idx].sum() - ic1[:, if_idx].sum(), pkt_count)
2166 self.assertEqual(dc2[:, if_idx].sum() - dc1[:, if_idx].sum(), 0)
2168 self.logger.info(self.vapi.cli("show trace"))
2171 tc1 = self.statistics['/nat44-ed/out2in/fastpath/tcp']
2172 uc1 = self.statistics['/nat44-ed/out2in/fastpath/udp']
2173 ic1 = self.statistics['/nat44-ed/out2in/fastpath/icmp']
2174 dc1 = self.statistics['/nat44-ed/out2in/fastpath/drops']
2176 recvd_tcp_ports = set()
2177 recvd_udp_ports = set()
2178 recvd_icmp_ids = set()
2182 recvd_tcp_ports.add(p[TCP].sport)
2184 recvd_udp_ports.add(p[UDP].sport)
2186 recvd_icmp_ids.add(p[ICMP].id)
2188 recvd_tcp_ports = list(recvd_tcp_ports)
2189 recvd_udp_ports = list(recvd_udp_ports)
2190 recvd_icmp_ids = list(recvd_icmp_ids)
2192 o2i_pkts = [[] for x in range(0, self.vpp_worker_count)]
2193 for i in range(pkt_count):
2194 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2195 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2196 TCP(dport=choice(recvd_tcp_ports), sport=20))
2197 o2i_pkts[p[TCP].dport % self.vpp_worker_count].append(p)
2199 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2200 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2201 UDP(dport=choice(recvd_udp_ports), sport=20))
2202 o2i_pkts[p[UDP].dport % self.vpp_worker_count].append(p)
2204 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2205 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2206 ICMP(id=choice(recvd_icmp_ids), type='echo-reply'))
2207 o2i_pkts[p[ICMP].id % self.vpp_worker_count].append(p)
2209 for i in range(0, self.vpp_worker_count):
2210 if len(o2i_pkts[i]) > 0:
2211 self.pg1.add_stream(o2i_pkts[i], worker=i)
2213 self.pg_enable_capture(self.pg_interfaces)
2215 capture = self.pg0.get_capture(pkt_count * 3)
2216 for packet in capture:
2218 self.assert_packet_checksums_valid(packet)
2219 self.assertEqual(packet[IP].dst, self.pg0.remote_ip4)
2220 if packet.haslayer(TCP):
2221 self.assert_in_range(
2222 packet[TCP].dport, tcp_port_offset,
2223 tcp_port_offset + pkt_count, "dst TCP port")
2224 elif packet.haslayer(UDP):
2225 self.assert_in_range(
2226 packet[UDP].dport, udp_port_offset,
2227 udp_port_offset + pkt_count, "dst UDP port")
2229 self.assert_in_range(
2230 packet[ICMP].id, icmp_id_offset,
2231 icmp_id_offset + pkt_count, "ICMP id")
2233 self.logger.error(ppp("Unexpected or invalid packet "
2234 "(inside network):", packet))
2237 if_idx = self.pg1.sw_if_index
2238 tc2 = self.statistics['/nat44-ed/out2in/fastpath/tcp']
2239 uc2 = self.statistics['/nat44-ed/out2in/fastpath/udp']
2240 ic2 = self.statistics['/nat44-ed/out2in/fastpath/icmp']
2241 dc2 = self.statistics['/nat44-ed/out2in/fastpath/drops']
2244 tc2[:, if_idx].sum() - tc1[:, if_idx].sum(), pkt_count)
2246 uc2[:, if_idx].sum() - uc1[:, if_idx].sum(), pkt_count)
2248 ic2[:, if_idx].sum() - ic1[:, if_idx].sum(), pkt_count)
2249 self.assertEqual(dc2[:, if_idx].sum() - dc1[:, if_idx].sum(), 0)
2251 sc = self.statistics['/nat44-ed/total-sessions']
2252 self.assertEqual(sc[:, 0].sum(), len(recvd_tcp_ports) +
2253 len(recvd_udp_ports) + len(recvd_icmp_ids))
2255 def test_frag_in_order(self):
2256 """ NAT44ED translate fragments arriving in order """
2258 self.nat_add_address(self.nat_addr)
2259 self.nat_add_inside_interface(self.pg0)
2260 self.nat_add_outside_interface(self.pg1)
2262 self.frag_in_order(proto=IP_PROTOS.tcp, ignore_port=True)
2263 self.frag_in_order(proto=IP_PROTOS.udp, ignore_port=True)
2264 self.frag_in_order(proto=IP_PROTOS.icmp, ignore_port=True)
2266 def test_frag_in_order_do_not_translate(self):
2267 """ NAT44ED don't translate fragments arriving in order """
2269 self.nat_add_address(self.nat_addr)
2270 self.nat_add_inside_interface(self.pg0)
2271 self.nat_add_outside_interface(self.pg1)
2272 self.vapi.nat44_forwarding_enable_disable(enable=True)
2274 self.frag_in_order(proto=IP_PROTOS.tcp, dont_translate=True)
2276 def test_frag_out_of_order(self):
2277 """ NAT44ED translate fragments arriving out of order """
2279 self.nat_add_address(self.nat_addr)
2280 self.nat_add_inside_interface(self.pg0)
2281 self.nat_add_outside_interface(self.pg1)
2283 self.frag_out_of_order(proto=IP_PROTOS.tcp, ignore_port=True)
2284 self.frag_out_of_order(proto=IP_PROTOS.udp, ignore_port=True)
2285 self.frag_out_of_order(proto=IP_PROTOS.icmp, ignore_port=True)
2287 def test_frag_in_order_in_plus_out(self):
2288 """ NAT44ED in+out interface fragments in order """
2290 in_port = self.random_port()
2291 out_port = self.random_port()
2293 self.nat_add_address(self.nat_addr)
2294 self.nat_add_inside_interface(self.pg0)
2295 self.nat_add_outside_interface(self.pg0)
2296 self.nat_add_inside_interface(self.pg1)
2297 self.nat_add_outside_interface(self.pg1)
2299 # add static mappings for server
2300 self.nat_add_static_mapping(self.server_addr,
2304 proto=IP_PROTOS.tcp)
2305 self.nat_add_static_mapping(self.server_addr,
2309 proto=IP_PROTOS.udp)
2310 self.nat_add_static_mapping(self.server_addr,
2312 proto=IP_PROTOS.icmp)
2314 # run tests for each protocol
2315 self.frag_in_order_in_plus_out(self.server_addr,
2320 self.frag_in_order_in_plus_out(self.server_addr,
2325 self.frag_in_order_in_plus_out(self.server_addr,
2331 def test_frag_out_of_order_in_plus_out(self):
2332 """ NAT44ED in+out interface fragments out of order """
2334 in_port = self.random_port()
2335 out_port = self.random_port()
2337 self.nat_add_address(self.nat_addr)
2338 self.nat_add_inside_interface(self.pg0)
2339 self.nat_add_outside_interface(self.pg0)
2340 self.nat_add_inside_interface(self.pg1)
2341 self.nat_add_outside_interface(self.pg1)
2343 # add static mappings for server
2344 self.nat_add_static_mapping(self.server_addr,
2348 proto=IP_PROTOS.tcp)
2349 self.nat_add_static_mapping(self.server_addr,
2353 proto=IP_PROTOS.udp)
2354 self.nat_add_static_mapping(self.server_addr,
2356 proto=IP_PROTOS.icmp)
2358 # run tests for each protocol
2359 self.frag_out_of_order_in_plus_out(self.server_addr,
2364 self.frag_out_of_order_in_plus_out(self.server_addr,
2369 self.frag_out_of_order_in_plus_out(self.server_addr,
2375 def test_reass_hairpinning(self):
2376 """ NAT44ED fragments hairpinning """
2378 server_addr = self.pg0.remote_hosts[1].ip4
2380 host_in_port = self.random_port()
2381 server_in_port = self.random_port()
2382 server_out_port = self.random_port()
2384 self.nat_add_address(self.nat_addr)
2385 self.nat_add_inside_interface(self.pg0)
2386 self.nat_add_outside_interface(self.pg1)
2388 # add static mapping for server
2389 self.nat_add_static_mapping(server_addr, self.nat_addr,
2390 server_in_port, server_out_port,
2391 proto=IP_PROTOS.tcp)
2392 self.nat_add_static_mapping(server_addr, self.nat_addr,
2393 server_in_port, server_out_port,
2394 proto=IP_PROTOS.udp)
2395 self.nat_add_static_mapping(server_addr, self.nat_addr)
2397 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2398 host_in_port, proto=IP_PROTOS.tcp,
2400 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2401 host_in_port, proto=IP_PROTOS.udp,
2403 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2404 host_in_port, proto=IP_PROTOS.icmp,
2407 def test_session_limit_per_vrf(self):
2408 """ NAT44ED per vrf session limit """
2411 inside_vrf10 = self.pg2
2416 # 2 interfaces pg0, pg1 (vrf10, limit 1 tcp session)
2417 # non existing vrf_id makes process core dump
2418 self.vapi.nat44_set_session_limit(session_limit=limit, vrf_id=10)
2420 self.nat_add_inside_interface(inside)
2421 self.nat_add_inside_interface(inside_vrf10)
2422 self.nat_add_outside_interface(outside)
2425 self.nat_add_interface_address(outside)
2427 # BUG: causing core dump - when bad vrf_id is specified
2428 # self.nat_add_address(outside.local_ip4, vrf_id=20)
2430 stream = self.create_tcp_stream(inside_vrf10, outside, limit * 2)
2431 inside_vrf10.add_stream(stream)
2433 self.pg_enable_capture(self.pg_interfaces)
2436 capture = outside.get_capture(limit)
2438 stream = self.create_tcp_stream(inside, outside, limit * 2)
2439 inside.add_stream(stream)
2441 self.pg_enable_capture(self.pg_interfaces)
2444 capture = outside.get_capture(len(stream))
2446 def test_show_max_translations(self):
2447 """ NAT44ED API test - max translations per thread """
2448 nat_config = self.vapi.nat_show_config_2()
2449 self.assertEqual(self.max_sessions,
2450 nat_config.max_translations_per_thread)
2452 def test_lru_cleanup(self):
2453 """ NAT44ED LRU cleanup algorithm """
2455 self.nat_add_address(self.nat_addr)
2456 self.nat_add_inside_interface(self.pg0)
2457 self.nat_add_outside_interface(self.pg1)
2459 self.vapi.nat_set_timeouts(
2460 udp=1, tcp_established=7440, tcp_transitory=30, icmp=1)
2462 tcp_port_out = self.init_tcp_session(self.pg0, self.pg1, 2000, 80)
2464 for i in range(0, self.max_sessions - 1):
2465 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2466 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4, ttl=64) /
2467 UDP(sport=7000+i, dport=80))
2470 self.pg0.add_stream(pkts)
2471 self.pg_enable_capture(self.pg_interfaces)
2473 self.pg1.get_capture(len(pkts))
2474 self.sleep(1.5, "wait for timeouts")
2477 for i in range(0, self.max_sessions - 1):
2478 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2479 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4, ttl=64) /
2480 ICMP(id=8000+i, type='echo-request'))
2483 self.pg0.add_stream(pkts)
2484 self.pg_enable_capture(self.pg_interfaces)
2486 self.pg1.get_capture(len(pkts))
2488 def test_session_rst_timeout(self):
2489 """ NAT44ED session RST timeouts """
2491 self.nat_add_address(self.nat_addr)
2492 self.nat_add_inside_interface(self.pg0)
2493 self.nat_add_outside_interface(self.pg1)
2495 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
2496 tcp_transitory=5, icmp=60)
2498 self.init_tcp_session(self.pg0, self.pg1, self.tcp_port_in,
2499 self.tcp_external_port)
2500 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2501 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2502 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port,
2504 self.pg0.add_stream(p)
2505 self.pg_enable_capture(self.pg_interfaces)
2507 self.pg1.get_capture(1)
2511 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2512 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2513 TCP(sport=self.tcp_port_in + 1, dport=self.tcp_external_port + 1,
2515 self.pg0.add_stream(p)
2516 self.pg_enable_capture(self.pg_interfaces)
2518 self.pg1.get_capture(1)
2520 def test_dynamic_out_of_ports(self):
2521 """ NAT44ED dynamic translation test: out of ports """
2523 self.nat_add_inside_interface(self.pg0)
2524 self.nat_add_outside_interface(self.pg1)
2526 # in2out and no NAT addresses added
2527 err_old = self.statistics.get_err_counter(
2528 '/err/nat44-ed-in2out-slowpath/out of ports')
2530 pkts = self.create_stream_in(self.pg0, self.pg1)
2531 self.pg0.add_stream(pkts)
2532 self.pg_enable_capture(self.pg_interfaces)
2534 self.pg1.get_capture(0, timeout=1)
2536 err_new = self.statistics.get_err_counter(
2537 '/err/nat44-ed-in2out-slowpath/out of ports')
2539 self.assertEqual(err_new - err_old, len(pkts))
2541 # in2out after NAT addresses added
2542 self.nat_add_address(self.nat_addr)
2544 err_old = self.statistics.get_err_counter(
2545 '/err/nat44-ed-in2out-slowpath/out of ports')
2547 pkts = self.create_stream_in(self.pg0, self.pg1)
2548 self.pg0.add_stream(pkts)
2549 self.pg_enable_capture(self.pg_interfaces)
2551 capture = self.pg1.get_capture(len(pkts))
2552 self.verify_capture_out(capture, ignore_port=True)
2554 err_new = self.statistics.get_err_counter(
2555 '/err/nat44-ed-in2out-slowpath/out of ports')
2557 self.assertEqual(err_new, err_old)
2559 def test_unknown_proto(self):
2560 """ NAT44ED translate packet with unknown protocol """
2562 self.nat_add_address(self.nat_addr)
2563 self.nat_add_inside_interface(self.pg0)
2564 self.nat_add_outside_interface(self.pg1)
2567 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2568 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2569 TCP(sport=self.tcp_port_in, dport=20))
2570 self.pg0.add_stream(p)
2571 self.pg_enable_capture(self.pg_interfaces)
2573 p = self.pg1.get_capture(1)
2575 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2576 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2578 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2579 TCP(sport=1234, dport=1234))
2580 self.pg0.add_stream(p)
2581 self.pg_enable_capture(self.pg_interfaces)
2583 p = self.pg1.get_capture(1)
2586 self.assertEqual(packet[IP].src, self.nat_addr)
2587 self.assertEqual(packet[IP].dst, self.pg1.remote_ip4)
2588 self.assertEqual(packet.haslayer(GRE), 1)
2589 self.assert_packet_checksums_valid(packet)
2591 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2595 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2596 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2598 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2599 TCP(sport=1234, dport=1234))
2600 self.pg1.add_stream(p)
2601 self.pg_enable_capture(self.pg_interfaces)
2603 p = self.pg0.get_capture(1)
2606 self.assertEqual(packet[IP].src, self.pg1.remote_ip4)
2607 self.assertEqual(packet[IP].dst, self.pg0.remote_ip4)
2608 self.assertEqual(packet.haslayer(GRE), 1)
2609 self.assert_packet_checksums_valid(packet)
2611 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2614 def test_hairpinning_unknown_proto(self):
2615 """ NAT44ED translate packet with unknown protocol - hairpinning """
2616 host = self.pg0.remote_hosts[0]
2617 server = self.pg0.remote_hosts[1]
2619 server_out_port = 8765
2620 server_nat_ip = "10.0.0.11"
2622 self.nat_add_address(self.nat_addr)
2623 self.nat_add_inside_interface(self.pg0)
2624 self.nat_add_outside_interface(self.pg1)
2626 # add static mapping for server
2627 self.nat_add_static_mapping(server.ip4, server_nat_ip)
2630 p = (Ether(src=host.mac, dst=self.pg0.local_mac) /
2631 IP(src=host.ip4, dst=server_nat_ip) /
2632 TCP(sport=host_in_port, dport=server_out_port))
2633 self.pg0.add_stream(p)
2634 self.pg_enable_capture(self.pg_interfaces)
2636 self.pg0.get_capture(1)
2638 p = (Ether(dst=self.pg0.local_mac, src=host.mac) /
2639 IP(src=host.ip4, dst=server_nat_ip) /
2641 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2642 TCP(sport=1234, dport=1234))
2643 self.pg0.add_stream(p)
2644 self.pg_enable_capture(self.pg_interfaces)
2646 p = self.pg0.get_capture(1)
2649 self.assertEqual(packet[IP].src, self.nat_addr)
2650 self.assertEqual(packet[IP].dst, server.ip4)
2651 self.assertEqual(packet.haslayer(GRE), 1)
2652 self.assert_packet_checksums_valid(packet)
2654 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2658 p = (Ether(dst=self.pg0.local_mac, src=server.mac) /
2659 IP(src=server.ip4, dst=self.nat_addr) /
2661 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2662 TCP(sport=1234, dport=1234))
2663 self.pg0.add_stream(p)
2664 self.pg_enable_capture(self.pg_interfaces)
2666 p = self.pg0.get_capture(1)
2669 self.assertEqual(packet[IP].src, server_nat_ip)
2670 self.assertEqual(packet[IP].dst, host.ip4)
2671 self.assertEqual(packet.haslayer(GRE), 1)
2672 self.assert_packet_checksums_valid(packet)
2674 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2677 def test_output_feature_and_service(self):
2678 """ NAT44ED interface output feature and services """
2679 external_addr = '1.2.3.4'
2683 self.vapi.nat44_forwarding_enable_disable(enable=1)
2684 self.nat_add_address(self.nat_addr)
2685 flags = self.config_flags.NAT_IS_ADDR_ONLY
2686 self.vapi.nat44_add_del_identity_mapping(
2687 ip_address=self.pg1.remote_ip4, sw_if_index=0xFFFFFFFF,
2688 flags=flags, is_add=1)
2689 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
2690 self.nat_add_static_mapping(self.pg0.remote_ip4, external_addr,
2691 local_port, external_port,
2692 proto=IP_PROTOS.tcp, flags=flags)
2694 self.nat_add_inside_interface(self.pg0)
2695 self.nat_add_outside_interface(self.pg0)
2696 self.vapi.nat44_interface_add_del_output_feature(
2697 sw_if_index=self.pg1.sw_if_index, is_add=1)
2699 # from client to service
2700 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2701 IP(src=self.pg1.remote_ip4, dst=external_addr) /
2702 TCP(sport=12345, dport=external_port))
2703 self.pg1.add_stream(p)
2704 self.pg_enable_capture(self.pg_interfaces)
2706 capture = self.pg0.get_capture(1)
2711 self.assertEqual(ip.dst, self.pg0.remote_ip4)
2712 self.assertEqual(tcp.dport, local_port)
2713 self.assert_packet_checksums_valid(p)
2715 self.logger.error(ppp("Unexpected or invalid packet:", p))
2718 # from service back to client
2719 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2720 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2721 TCP(sport=local_port, dport=12345))
2722 self.pg0.add_stream(p)
2723 self.pg_enable_capture(self.pg_interfaces)
2725 capture = self.pg1.get_capture(1)
2730 self.assertEqual(ip.src, external_addr)
2731 self.assertEqual(tcp.sport, external_port)
2732 self.assert_packet_checksums_valid(p)
2734 self.logger.error(ppp("Unexpected or invalid packet:", p))
2737 # from local network host to external network
2738 pkts = self.create_stream_in(self.pg0, self.pg1)
2739 self.pg0.add_stream(pkts)
2740 self.pg_enable_capture(self.pg_interfaces)
2742 capture = self.pg1.get_capture(len(pkts))
2743 self.verify_capture_out(capture, ignore_port=True)
2744 pkts = self.create_stream_in(self.pg0, self.pg1)
2745 self.pg0.add_stream(pkts)
2746 self.pg_enable_capture(self.pg_interfaces)
2748 capture = self.pg1.get_capture(len(pkts))
2749 self.verify_capture_out(capture, ignore_port=True)
2751 # from external network back to local network host
2752 pkts = self.create_stream_out(self.pg1)
2753 self.pg1.add_stream(pkts)
2754 self.pg_enable_capture(self.pg_interfaces)
2756 capture = self.pg0.get_capture(len(pkts))
2757 self.verify_capture_in(capture, self.pg0)
2759 def test_output_feature_and_service3(self):
2760 """ NAT44ED interface output feature and DST NAT """
2761 external_addr = '1.2.3.4'
2765 self.vapi.nat44_forwarding_enable_disable(enable=1)
2766 self.nat_add_address(self.nat_addr)
2767 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
2768 self.nat_add_static_mapping(self.pg1.remote_ip4, external_addr,
2769 local_port, external_port,
2770 proto=IP_PROTOS.tcp, flags=flags)
2772 self.nat_add_inside_interface(self.pg0)
2773 self.nat_add_outside_interface(self.pg0)
2774 self.vapi.nat44_interface_add_del_output_feature(
2775 sw_if_index=self.pg1.sw_if_index, is_add=1)
2777 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2778 IP(src=self.pg0.remote_ip4, dst=external_addr) /
2779 TCP(sport=12345, dport=external_port))
2780 self.pg0.add_stream(p)
2781 self.pg_enable_capture(self.pg_interfaces)
2783 capture = self.pg1.get_capture(1)
2788 self.assertEqual(ip.src, self.pg0.remote_ip4)
2789 self.assertEqual(tcp.sport, 12345)
2790 self.assertEqual(ip.dst, self.pg1.remote_ip4)
2791 self.assertEqual(tcp.dport, local_port)
2792 self.assert_packet_checksums_valid(p)
2794 self.logger.error(ppp("Unexpected or invalid packet:", p))
2797 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2798 IP(src=self.pg1.remote_ip4, dst=self.pg0.remote_ip4) /
2799 TCP(sport=local_port, dport=12345))
2800 self.pg1.add_stream(p)
2801 self.pg_enable_capture(self.pg_interfaces)
2803 capture = self.pg0.get_capture(1)
2808 self.assertEqual(ip.src, external_addr)
2809 self.assertEqual(tcp.sport, external_port)
2810 self.assertEqual(ip.dst, self.pg0.remote_ip4)
2811 self.assertEqual(tcp.dport, 12345)
2812 self.assert_packet_checksums_valid(p)
2814 self.logger.error(ppp("Unexpected or invalid packet:", p))
2817 def test_self_twice_nat_lb_negative(self):
2818 """ NAT44ED Self Twice NAT local service load balancing (negative test)
2820 self.twice_nat_common(lb=True, self_twice_nat=True, same_pg=True,
2823 def test_self_twice_nat_negative(self):
2824 """ NAT44ED Self Twice NAT (negative test) """
2825 self.twice_nat_common(self_twice_nat=True)
2827 def test_static_lb_multi_clients(self):
2828 """ NAT44ED local service load balancing - multiple clients"""
2830 external_addr = self.nat_addr
2833 server1 = self.pg0.remote_hosts[0]
2834 server2 = self.pg0.remote_hosts[1]
2835 server3 = self.pg0.remote_hosts[2]
2837 locals = [{'addr': server1.ip4,
2841 {'addr': server2.ip4,
2846 flags = self.config_flags.NAT_IS_INSIDE
2847 self.vapi.nat44_interface_add_del_feature(
2848 sw_if_index=self.pg0.sw_if_index,
2849 flags=flags, is_add=1)
2850 self.vapi.nat44_interface_add_del_feature(
2851 sw_if_index=self.pg1.sw_if_index,
2854 self.nat_add_address(self.nat_addr)
2855 self.vapi.nat44_add_del_lb_static_mapping(is_add=1,
2856 external_addr=external_addr,
2857 external_port=external_port,
2858 protocol=IP_PROTOS.tcp,
2859 local_num=len(locals),
2864 clients = ip4_range(self.pg1.remote_ip4, 10, 50)
2866 for client in clients:
2867 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2868 IP(src=client, dst=self.nat_addr) /
2869 TCP(sport=12345, dport=external_port))
2871 self.pg1.add_stream(pkts)
2872 self.pg_enable_capture(self.pg_interfaces)
2874 capture = self.pg0.get_capture(len(pkts))
2876 if p[IP].dst == server1.ip4:
2880 self.assertGreaterEqual(server1_n, server2_n)
2883 'addr': server3.ip4,
2890 self.vapi.nat44_lb_static_mapping_add_del_local(
2892 external_addr=external_addr,
2893 external_port=external_port,
2895 protocol=IP_PROTOS.tcp)
2899 clients = ip4_range(self.pg1.remote_ip4, 60, 110)
2901 for client in clients:
2902 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2903 IP(src=client, dst=self.nat_addr) /
2904 TCP(sport=12346, dport=external_port))
2906 self.assertGreater(len(pkts), 0)
2907 self.pg1.add_stream(pkts)
2908 self.pg_enable_capture(self.pg_interfaces)
2910 capture = self.pg0.get_capture(len(pkts))
2912 if p[IP].dst == server1.ip4:
2914 elif p[IP].dst == server2.ip4:
2918 self.assertGreater(server1_n, 0)
2919 self.assertGreater(server2_n, 0)
2920 self.assertGreater(server3_n, 0)
2923 'addr': server2.ip4,
2929 # remove one back-end
2930 self.vapi.nat44_lb_static_mapping_add_del_local(
2932 external_addr=external_addr,
2933 external_port=external_port,
2935 protocol=IP_PROTOS.tcp)
2939 self.pg1.add_stream(pkts)
2940 self.pg_enable_capture(self.pg_interfaces)
2942 capture = self.pg0.get_capture(len(pkts))
2944 if p[IP].dst == server1.ip4:
2946 elif p[IP].dst == server2.ip4:
2950 self.assertGreater(server1_n, 0)
2951 self.assertEqual(server2_n, 0)
2952 self.assertGreater(server3_n, 0)
2954 def test_syslog_sess(self):
2955 """ NAT44ED Test syslog session creation and deletion """
2956 self.vapi.syslog_set_filter(
2957 self.syslog_severity.SYSLOG_API_SEVERITY_INFO)
2958 self.vapi.syslog_set_sender(self.pg3.local_ip4, self.pg3.remote_ip4)
2960 self.nat_add_address(self.nat_addr)
2961 self.nat_add_inside_interface(self.pg0)
2962 self.nat_add_outside_interface(self.pg1)
2964 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2965 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2966 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port))
2967 self.pg0.add_stream(p)
2968 self.pg_enable_capture(self.pg_interfaces)
2970 capture = self.pg1.get_capture(1)
2971 self.tcp_port_out = capture[0][TCP].sport
2972 capture = self.pg3.get_capture(1)
2973 self.verify_syslog_sess(capture[0][Raw].load)
2975 self.pg_enable_capture(self.pg_interfaces)
2977 self.nat_add_address(self.nat_addr, is_add=0)
2978 capture = self.pg3.get_capture(1)
2979 self.verify_syslog_sess(capture[0][Raw].load, False)
2981 def test_twice_nat_interface_addr(self):
2982 """ NAT44ED Acquire twice NAT addresses from interface """
2983 flags = self.config_flags.NAT_IS_TWICE_NAT
2984 self.vapi.nat44_add_del_interface_addr(
2985 sw_if_index=self.pg11.sw_if_index,
2986 flags=flags, is_add=1)
2988 # no address in NAT pool
2989 adresses = self.vapi.nat44_address_dump()
2990 self.assertEqual(0, len(adresses))
2992 # configure interface address and check NAT address pool
2993 self.pg11.config_ip4()
2994 adresses = self.vapi.nat44_address_dump()
2995 self.assertEqual(1, len(adresses))
2996 self.assertEqual(str(adresses[0].ip_address),
2997 self.pg11.local_ip4)
2998 self.assertEqual(adresses[0].flags, flags)
3000 # remove interface address and check NAT address pool
3001 self.pg11.unconfig_ip4()
3002 adresses = self.vapi.nat44_address_dump()
3003 self.assertEqual(0, len(adresses))
3005 def test_output_feature_stateful_acl(self):
3006 """ NAT44ED output feature works with stateful ACL """
3008 self.nat_add_address(self.nat_addr)
3009 self.vapi.nat44_interface_add_del_output_feature(
3010 sw_if_index=self.pg0.sw_if_index,
3011 flags=self.config_flags.NAT_IS_INSIDE, is_add=1)
3012 self.vapi.nat44_interface_add_del_output_feature(
3013 sw_if_index=self.pg1.sw_if_index,
3014 flags=self.config_flags.NAT_IS_OUTSIDE, is_add=1)
3016 # First ensure that the NAT is working sans ACL
3018 # send packets out2in, no sessions yet so packets should drop
3019 pkts_out2in = self.create_stream_out(self.pg1)
3020 self.send_and_assert_no_replies(self.pg1, pkts_out2in)
3022 # send packets into inside intf, ensure received via outside intf
3023 pkts_in2out = self.create_stream_in(self.pg0, self.pg1)
3024 capture = self.send_and_expect(self.pg0, pkts_in2out, self.pg1,
3026 self.verify_capture_out(capture, ignore_port=True)
3028 # send out2in again, with sessions created it should work now
3029 pkts_out2in = self.create_stream_out(self.pg1)
3030 capture = self.send_and_expect(self.pg1, pkts_out2in, self.pg0,
3032 self.verify_capture_in(capture, self.pg0)
3034 # Create an ACL blocking everything
3035 out2in_deny_rule = AclRule(is_permit=0)
3036 out2in_acl = VppAcl(self, rules=[out2in_deny_rule])
3037 out2in_acl.add_vpp_config()
3039 # create an ACL to permit/reflect everything
3040 in2out_reflect_rule = AclRule(is_permit=2)
3041 in2out_acl = VppAcl(self, rules=[in2out_reflect_rule])
3042 in2out_acl.add_vpp_config()
3044 # apply as input acl on interface and confirm it blocks everything
3045 acl_if = VppAclInterface(self, sw_if_index=self.pg1.sw_if_index,
3046 n_input=1, acls=[out2in_acl])
3047 acl_if.add_vpp_config()
3048 self.send_and_assert_no_replies(self.pg1, pkts_out2in)
3051 acl_if.acls = [out2in_acl, in2out_acl]
3052 acl_if.add_vpp_config()
3053 # send in2out to generate ACL state (NAT state was created earlier)
3054 capture = self.send_and_expect(self.pg0, pkts_in2out, self.pg1,
3056 self.verify_capture_out(capture, ignore_port=True)
3058 # send out2in again. ACL state exists so it should work now.
3059 # TCP packets with the syn flag set also need the ack flag
3060 for p in pkts_out2in:
3061 if p.haslayer(TCP) and p[TCP].flags & 0x02:
3062 p[TCP].flags |= 0x10
3063 capture = self.send_and_expect(self.pg1, pkts_out2in, self.pg0,
3065 self.verify_capture_in(capture, self.pg0)
3066 self.logger.info(self.vapi.cli("show trace"))
3068 def test_tcp_close(self):
3069 """ NAT44ED Close TCP session from inside network - output feature """
3070 old_timeouts = self.vapi.nat_get_timeouts()
3072 self.vapi.nat_set_timeouts(
3073 udp=old_timeouts.udp,
3074 tcp_established=old_timeouts.tcp_established,
3075 icmp=old_timeouts.icmp,
3076 tcp_transitory=new_transitory)
3078 self.vapi.nat44_forwarding_enable_disable(enable=1)
3079 self.nat_add_address(self.pg1.local_ip4)
3080 twice_nat_addr = '10.0.1.3'
3081 service_ip = '192.168.16.150'
3082 self.nat_add_address(twice_nat_addr, twice_nat=1)
3084 flags = self.config_flags.NAT_IS_INSIDE
3085 self.vapi.nat44_interface_add_del_feature(
3086 sw_if_index=self.pg0.sw_if_index,
3088 self.vapi.nat44_interface_add_del_feature(
3089 sw_if_index=self.pg0.sw_if_index,
3090 flags=flags, is_add=1)
3091 self.vapi.nat44_interface_add_del_output_feature(
3093 sw_if_index=self.pg1.sw_if_index)
3095 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3096 self.config_flags.NAT_IS_TWICE_NAT)
3097 self.nat_add_static_mapping(self.pg0.remote_ip4,
3099 proto=IP_PROTOS.tcp,
3101 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3102 start_sessnum = len(sessions)
3104 # SYN packet out->in
3105 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3106 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3107 TCP(sport=33898, dport=80, flags="S"))
3108 self.pg1.add_stream(p)
3109 self.pg_enable_capture(self.pg_interfaces)
3111 capture = self.pg0.get_capture(1)
3113 tcp_port = p[TCP].sport
3115 # SYN + ACK packet in->out
3116 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3117 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3118 TCP(sport=80, dport=tcp_port, flags="SA"))
3119 self.pg0.add_stream(p)
3120 self.pg_enable_capture(self.pg_interfaces)
3122 self.pg1.get_capture(1)
3124 # ACK packet out->in
3125 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3126 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3127 TCP(sport=33898, dport=80, flags="A"))
3128 self.pg1.add_stream(p)
3129 self.pg_enable_capture(self.pg_interfaces)
3131 self.pg0.get_capture(1)
3133 # FIN packet in -> out
3134 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3135 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3136 TCP(sport=80, dport=tcp_port, flags="FA", seq=100, ack=300))
3137 self.pg0.add_stream(p)
3138 self.pg_enable_capture(self.pg_interfaces)
3140 self.pg1.get_capture(1)
3142 # FIN+ACK packet out -> in
3143 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3144 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3145 TCP(sport=33898, dport=80, flags="FA", seq=300, ack=101))
3146 self.pg1.add_stream(p)
3147 self.pg_enable_capture(self.pg_interfaces)
3149 self.pg0.get_capture(1)
3151 # ACK packet in -> out
3152 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3153 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3154 TCP(sport=80, dport=tcp_port, flags="A", seq=101, ack=301))
3155 self.pg0.add_stream(p)
3156 self.pg_enable_capture(self.pg_interfaces)
3158 self.pg1.get_capture(1)
3160 # session now in transitory timeout
3161 # try SYN packet out->in - should be dropped
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)
3169 self.sleep(new_transitory, "wait for transitory timeout")
3170 self.pg0.assert_nothing_captured(0)
3172 # session should still exist
3173 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3174 self.assertEqual(len(sessions) - start_sessnum, 1)
3176 # send FIN+ACK packet out -> in - will cause session to be wiped
3177 # but won't create a new session
3178 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3179 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3180 TCP(sport=33898, dport=80, flags="FA", seq=300, ack=101))
3181 self.pg1.add_stream(p)
3182 self.pg_enable_capture(self.pg_interfaces)
3185 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3186 self.assertEqual(len(sessions) - start_sessnum, 0)
3187 self.pg0.assert_nothing_captured(0)
3189 def test_tcp_session_close_in(self):
3190 """ NAT44ED Close TCP session from inside network """
3192 in_port = self.tcp_port_in
3194 ext_port = self.tcp_external_port
3196 self.nat_add_address(self.nat_addr)
3197 self.nat_add_inside_interface(self.pg0)
3198 self.nat_add_outside_interface(self.pg1)
3199 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3200 in_port, out_port, proto=IP_PROTOS.tcp,
3201 flags=self.config_flags.NAT_IS_TWICE_NAT)
3203 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3204 session_n = len(sessions)
3206 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3207 tcp_transitory=2, icmp=5)
3209 self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3211 # FIN packet in -> out
3212 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3213 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3214 TCP(sport=in_port, dport=ext_port,
3215 flags="FA", seq=100, ack=300))
3216 self.pg0.add_stream(p)
3217 self.pg_enable_capture(self.pg_interfaces)
3219 self.pg1.get_capture(1)
3223 # ACK packet out -> in
3224 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3225 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3226 TCP(sport=ext_port, dport=out_port,
3227 flags="A", seq=300, ack=101))
3230 # FIN packet out -> in
3231 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3232 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3233 TCP(sport=ext_port, dport=out_port,
3234 flags="FA", seq=300, ack=101))
3237 self.pg1.add_stream(pkts)
3238 self.pg_enable_capture(self.pg_interfaces)
3240 self.pg0.get_capture(2)
3242 # ACK packet in -> out
3243 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3244 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3245 TCP(sport=in_port, dport=ext_port,
3246 flags="A", seq=101, ack=301))
3247 self.pg0.add_stream(p)
3248 self.pg_enable_capture(self.pg_interfaces)
3250 self.pg1.get_capture(1)
3252 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3253 self.assertEqual(len(sessions) - session_n, 1)
3255 out2in_drops = self.get_err_counter(
3256 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3257 in2out_drops = self.get_err_counter(
3258 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3260 # extra FIN packet out -> in - this should be dropped
3261 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3262 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3263 TCP(sport=ext_port, dport=out_port,
3264 flags="FA", seq=300, ack=101))
3266 self.pg1.add_stream(p)
3267 self.pg_enable_capture(self.pg_interfaces)
3269 self.pg0.assert_nothing_captured()
3271 # extra ACK packet in -> out - this should be dropped
3272 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3273 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3274 TCP(sport=in_port, dport=ext_port,
3275 flags="A", seq=101, ack=301))
3276 self.pg0.add_stream(p)
3277 self.pg_enable_capture(self.pg_interfaces)
3279 self.pg1.assert_nothing_captured()
3281 stats = self.get_err_counter(
3282 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3283 self.assertEqual(stats - out2in_drops, 1)
3284 stats = self.get_err_counter(
3285 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3286 self.assertEqual(stats - in2out_drops, 1)
3289 # extra ACK packet in -> out - this will cause session to be wiped
3290 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3291 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3292 TCP(sport=in_port, dport=ext_port,
3293 flags="A", seq=101, ack=301))
3294 self.pg0.add_stream(p)
3295 self.pg_enable_capture(self.pg_interfaces)
3297 self.pg1.assert_nothing_captured()
3298 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3299 self.assertEqual(len(sessions) - session_n, 0)
3301 def test_tcp_session_close_out(self):
3302 """ NAT44ED Close TCP session from outside network """
3304 in_port = self.tcp_port_in
3306 ext_port = self.tcp_external_port
3308 self.nat_add_address(self.nat_addr)
3309 self.nat_add_inside_interface(self.pg0)
3310 self.nat_add_outside_interface(self.pg1)
3311 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3312 in_port, out_port, proto=IP_PROTOS.tcp,
3313 flags=self.config_flags.NAT_IS_TWICE_NAT)
3315 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3316 session_n = len(sessions)
3318 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3319 tcp_transitory=2, icmp=5)
3321 _ = self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3323 # FIN packet out -> in
3324 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3325 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3326 TCP(sport=ext_port, dport=out_port,
3327 flags="FA", seq=100, ack=300))
3328 self.pg1.add_stream(p)
3329 self.pg_enable_capture(self.pg_interfaces)
3331 self.pg0.get_capture(1)
3333 # FIN+ACK packet in -> out
3334 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3335 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3336 TCP(sport=in_port, dport=ext_port,
3337 flags="FA", seq=300, ack=101))
3339 self.pg0.add_stream(p)
3340 self.pg_enable_capture(self.pg_interfaces)
3342 self.pg1.get_capture(1)
3344 # ACK packet out -> in
3345 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3346 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3347 TCP(sport=ext_port, dport=out_port,
3348 flags="A", seq=101, ack=301))
3349 self.pg1.add_stream(p)
3350 self.pg_enable_capture(self.pg_interfaces)
3352 self.pg0.get_capture(1)
3354 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3355 self.assertEqual(len(sessions) - session_n, 1)
3357 out2in_drops = self.get_err_counter(
3358 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3359 in2out_drops = self.get_err_counter(
3360 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3362 # extra FIN packet out -> in - this should be dropped
3363 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3364 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3365 TCP(sport=ext_port, dport=out_port,
3366 flags="FA", seq=300, ack=101))
3368 self.pg1.add_stream(p)
3369 self.pg_enable_capture(self.pg_interfaces)
3371 self.pg0.assert_nothing_captured()
3373 # extra ACK packet in -> out - this should be dropped
3374 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3375 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3376 TCP(sport=in_port, dport=ext_port,
3377 flags="A", seq=101, ack=301))
3378 self.pg0.add_stream(p)
3379 self.pg_enable_capture(self.pg_interfaces)
3381 self.pg1.assert_nothing_captured()
3383 stats = self.get_err_counter(
3384 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3385 self.assertEqual(stats - out2in_drops, 1)
3386 stats = self.get_err_counter(
3387 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3388 self.assertEqual(stats - in2out_drops, 1)
3391 # extra ACK packet in -> out - this will cause session to be wiped
3392 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3393 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3394 TCP(sport=in_port, dport=ext_port,
3395 flags="A", seq=101, ack=301))
3396 self.pg0.add_stream(p)
3397 self.pg_enable_capture(self.pg_interfaces)
3399 self.pg1.assert_nothing_captured()
3400 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3401 self.assertEqual(len(sessions) - session_n, 0)
3403 def test_tcp_session_close_simultaneous(self):
3404 """ NAT44ED Close TCP session from inside network """
3406 in_port = self.tcp_port_in
3409 self.nat_add_address(self.nat_addr)
3410 self.nat_add_inside_interface(self.pg0)
3411 self.nat_add_outside_interface(self.pg1)
3412 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3413 in_port, ext_port, proto=IP_PROTOS.tcp,
3414 flags=self.config_flags.NAT_IS_TWICE_NAT)
3416 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3417 session_n = len(sessions)
3419 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3420 tcp_transitory=2, icmp=5)
3422 out_port = self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3424 # FIN packet in -> out
3425 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3426 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3427 TCP(sport=in_port, dport=ext_port,
3428 flags="FA", seq=100, ack=300))
3429 self.pg0.add_stream(p)
3430 self.pg_enable_capture(self.pg_interfaces)
3432 self.pg1.get_capture(1)
3434 # FIN packet out -> in
3435 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3436 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3437 TCP(sport=ext_port, dport=out_port,
3438 flags="FA", seq=300, ack=100))
3439 self.pg1.add_stream(p)
3440 self.pg_enable_capture(self.pg_interfaces)
3442 self.pg0.get_capture(1)
3444 # ACK packet in -> out
3445 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3446 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3447 TCP(sport=in_port, dport=ext_port,
3448 flags="A", seq=101, ack=301))
3449 self.pg0.add_stream(p)
3450 self.pg_enable_capture(self.pg_interfaces)
3452 self.pg1.get_capture(1)
3454 # ACK packet out -> in
3455 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3456 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3457 TCP(sport=ext_port, dport=out_port,
3458 flags="A", seq=301, ack=101))
3459 self.pg1.add_stream(p)
3460 self.pg_enable_capture(self.pg_interfaces)
3462 self.pg0.get_capture(1)
3464 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3465 self.assertEqual(len(sessions) - session_n, 1)
3467 out2in_drops = self.get_err_counter(
3468 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3469 in2out_drops = self.get_err_counter(
3470 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3472 # extra FIN packet out -> in - this should be dropped
3473 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3474 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3475 TCP(sport=ext_port, dport=out_port,
3476 flags="FA", seq=300, ack=101))
3478 self.pg1.add_stream(p)
3479 self.pg_enable_capture(self.pg_interfaces)
3481 self.pg0.assert_nothing_captured()
3483 # extra ACK packet in -> out - this should be dropped
3484 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3485 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3486 TCP(sport=in_port, dport=ext_port,
3487 flags="A", seq=101, ack=301))
3488 self.pg0.add_stream(p)
3489 self.pg_enable_capture(self.pg_interfaces)
3491 self.pg1.assert_nothing_captured()
3493 stats = self.get_err_counter(
3494 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3495 self.assertEqual(stats - out2in_drops, 1)
3496 stats = self.get_err_counter(
3497 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3498 self.assertEqual(stats - in2out_drops, 1)
3501 # extra ACK packet in -> out - this will cause session to be wiped
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.assert_nothing_captured()
3510 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3511 self.assertEqual(len(sessions) - session_n, 0)
3513 def test_dynamic_vrf(self):
3514 """ NAT44ED dynamic translation test: different VRF"""
3519 self.nat_add_address(self.nat_addr, vrf_id=vrf_id_in)
3522 self.configure_ip4_interface(self.pg7, table_id=vrf_id_in)
3523 self.configure_ip4_interface(self.pg8, table_id=vrf_id_out)
3525 self.nat_add_inside_interface(self.pg7)
3526 self.nat_add_outside_interface(self.pg8)
3528 # just basic stuff nothing special
3529 pkts = self.create_stream_in(self.pg7, self.pg8)
3530 self.pg7.add_stream(pkts)
3531 self.pg_enable_capture(self.pg_interfaces)
3533 capture = self.pg8.get_capture(len(pkts))
3534 self.verify_capture_out(capture, ignore_port=True)
3536 pkts = self.create_stream_out(self.pg8)
3537 self.pg8.add_stream(pkts)
3538 self.pg_enable_capture(self.pg_interfaces)
3540 capture = self.pg7.get_capture(len(pkts))
3541 self.verify_capture_in(capture, self.pg7)
3547 self.vapi.ip_table_add_del(is_add=0,
3548 table={'table_id': vrf_id_in})
3549 self.vapi.ip_table_add_del(is_add=0,
3550 table={'table_id': vrf_id_out})
3552 def test_dynamic_output_feature_vrf(self):
3553 """ NAT44ED dynamic translation test: output-feature, VRF"""
3555 # other then default (0)
3558 self.nat_add_address(self.nat_addr)
3559 flags = self.config_flags.NAT_IS_INSIDE
3560 self.vapi.nat44_interface_add_del_output_feature(
3561 sw_if_index=self.pg7.sw_if_index,
3562 flags=flags, is_add=1)
3563 self.vapi.nat44_interface_add_del_output_feature(
3564 sw_if_index=self.pg8.sw_if_index,
3568 self.configure_ip4_interface(self.pg7, table_id=new_vrf_id)
3569 self.configure_ip4_interface(self.pg8, table_id=new_vrf_id)
3572 tcpn = self.statistics['/nat44-ed/in2out/slowpath/tcp']
3573 udpn = self.statistics['/nat44-ed/in2out/slowpath/udp']
3574 icmpn = self.statistics['/nat44-ed/in2out/slowpath/icmp']
3575 drops = self.statistics['/nat44-ed/in2out/slowpath/drops']
3577 pkts = self.create_stream_in(self.pg7, self.pg8)
3578 self.pg7.add_stream(pkts)
3579 self.pg_enable_capture(self.pg_interfaces)
3581 capture = self.pg8.get_capture(len(pkts))
3582 self.verify_capture_out(capture, ignore_port=True)
3584 if_idx = self.pg7.sw_if_index
3585 cnt = self.statistics['/nat44-ed/in2out/slowpath/tcp']
3586 self.assertEqual(cnt[:, if_idx].sum() - tcpn[:, if_idx].sum(), 2)
3587 cnt = self.statistics['/nat44-ed/in2out/slowpath/udp']
3588 self.assertEqual(cnt[:, if_idx].sum() - udpn[:, if_idx].sum(), 1)
3589 cnt = self.statistics['/nat44-ed/in2out/slowpath/icmp']
3590 self.assertEqual(cnt[:, if_idx].sum() - icmpn[:, if_idx].sum(), 1)
3591 cnt = self.statistics['/nat44-ed/in2out/slowpath/drops']
3592 self.assertEqual(cnt[:, if_idx].sum() - drops[:, if_idx].sum(), 0)
3595 tcpn = self.statistics['/nat44-ed/out2in/fastpath/tcp']
3596 udpn = self.statistics['/nat44-ed/out2in/fastpath/udp']
3597 icmpn = self.statistics['/nat44-ed/out2in/fastpath/icmp']
3598 drops = self.statistics['/nat44-ed/out2in/fastpath/drops']
3600 pkts = self.create_stream_out(self.pg8)
3601 self.pg8.add_stream(pkts)
3602 self.pg_enable_capture(self.pg_interfaces)
3604 capture = self.pg7.get_capture(len(pkts))
3605 self.verify_capture_in(capture, self.pg7)
3607 if_idx = self.pg8.sw_if_index
3608 cnt = self.statistics['/nat44-ed/out2in/fastpath/tcp']
3609 self.assertEqual(cnt[:, if_idx].sum() - tcpn[:, if_idx].sum(), 2)
3610 cnt = self.statistics['/nat44-ed/out2in/fastpath/udp']
3611 self.assertEqual(cnt[:, if_idx].sum() - udpn[:, if_idx].sum(), 1)
3612 cnt = self.statistics['/nat44-ed/out2in/fastpath/icmp']
3613 self.assertEqual(cnt[:, if_idx].sum() - icmpn[:, if_idx].sum(), 1)
3614 cnt = self.statistics['/nat44-ed/out2in/fastpath/drops']
3615 self.assertEqual(cnt[:, if_idx].sum() - drops[:, if_idx].sum(), 0)
3617 sessions = self.statistics['/nat44-ed/total-sessions']
3618 self.assertEqual(sessions[:, 0].sum(), 3)
3624 self.vapi.ip_table_add_del(is_add=0,
3625 table={'table_id': new_vrf_id})
3627 def test_next_src_nat(self):
3628 """ NAT44ED On way back forward packet to nat44-in2out node. """
3630 twice_nat_addr = '10.0.1.3'
3633 post_twice_nat_port = 0
3635 self.vapi.nat44_forwarding_enable_disable(enable=1)
3636 self.nat_add_address(twice_nat_addr, twice_nat=1)
3637 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3638 self.config_flags.NAT_IS_SELF_TWICE_NAT)
3639 self.nat_add_static_mapping(self.pg6.remote_ip4, self.pg1.remote_ip4,
3640 local_port, external_port,
3641 proto=IP_PROTOS.tcp, vrf_id=1,
3643 self.vapi.nat44_interface_add_del_feature(
3644 sw_if_index=self.pg6.sw_if_index,
3647 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
3648 IP(src=self.pg6.remote_ip4, dst=self.pg1.remote_ip4) /
3649 TCP(sport=12345, dport=external_port))
3650 self.pg6.add_stream(p)
3651 self.pg_enable_capture(self.pg_interfaces)
3653 capture = self.pg6.get_capture(1)
3658 self.assertEqual(ip.src, twice_nat_addr)
3659 self.assertNotEqual(tcp.sport, 12345)
3660 post_twice_nat_port = tcp.sport
3661 self.assertEqual(ip.dst, self.pg6.remote_ip4)
3662 self.assertEqual(tcp.dport, local_port)
3663 self.assert_packet_checksums_valid(p)
3665 self.logger.error(ppp("Unexpected or invalid packet:", p))
3668 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
3669 IP(src=self.pg6.remote_ip4, dst=twice_nat_addr) /
3670 TCP(sport=local_port, dport=post_twice_nat_port))
3671 self.pg6.add_stream(p)
3672 self.pg_enable_capture(self.pg_interfaces)
3674 capture = self.pg6.get_capture(1)
3679 self.assertEqual(ip.src, self.pg1.remote_ip4)
3680 self.assertEqual(tcp.sport, external_port)
3681 self.assertEqual(ip.dst, self.pg6.remote_ip4)
3682 self.assertEqual(tcp.dport, 12345)
3683 self.assert_packet_checksums_valid(p)
3685 self.logger.error(ppp("Unexpected or invalid packet:", p))
3688 def test_one_armed_nat44_static(self):
3689 """ NAT44ED One armed NAT and 1:1 NAPT asymmetrical rule """
3691 remote_host = self.pg4.remote_hosts[0]
3692 local_host = self.pg4.remote_hosts[1]
3697 self.vapi.nat44_forwarding_enable_disable(enable=1)
3698 self.nat_add_address(self.nat_addr, twice_nat=1)
3699 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3700 self.config_flags.NAT_IS_TWICE_NAT)
3701 self.nat_add_static_mapping(local_host.ip4, self.nat_addr,
3702 local_port, external_port,
3703 proto=IP_PROTOS.tcp, flags=flags)
3704 flags = self.config_flags.NAT_IS_INSIDE
3705 self.vapi.nat44_interface_add_del_feature(
3706 sw_if_index=self.pg4.sw_if_index,
3708 self.vapi.nat44_interface_add_del_feature(
3709 sw_if_index=self.pg4.sw_if_index,
3710 flags=flags, is_add=1)
3712 # from client to service
3713 p = (Ether(src=self.pg4.remote_mac, dst=self.pg4.local_mac) /
3714 IP(src=remote_host.ip4, dst=self.nat_addr) /
3715 TCP(sport=12345, dport=external_port))
3716 self.pg4.add_stream(p)
3717 self.pg_enable_capture(self.pg_interfaces)
3719 capture = self.pg4.get_capture(1)
3724 self.assertEqual(ip.dst, local_host.ip4)
3725 self.assertEqual(ip.src, self.nat_addr)
3726 self.assertEqual(tcp.dport, local_port)
3727 self.assertNotEqual(tcp.sport, 12345)
3728 eh_port_in = tcp.sport
3729 self.assert_packet_checksums_valid(p)
3731 self.logger.error(ppp("Unexpected or invalid packet:", p))
3734 # from service back to client
3735 p = (Ether(src=self.pg4.remote_mac, dst=self.pg4.local_mac) /
3736 IP(src=local_host.ip4, dst=self.nat_addr) /
3737 TCP(sport=local_port, dport=eh_port_in))
3738 self.pg4.add_stream(p)
3739 self.pg_enable_capture(self.pg_interfaces)
3741 capture = self.pg4.get_capture(1)
3746 self.assertEqual(ip.src, self.nat_addr)
3747 self.assertEqual(ip.dst, remote_host.ip4)
3748 self.assertEqual(tcp.sport, external_port)
3749 self.assertEqual(tcp.dport, 12345)
3750 self.assert_packet_checksums_valid(p)
3752 self.logger.error(ppp("Unexpected or invalid packet:", p))
3756 if __name__ == '__main__':
3757 unittest.main(testRunner=VppTestRunner)