5 from random import randint, 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
20 from util import StatsDiff
23 class TestNAT44ED(VppTestCase):
24 """ NAT44ED Test Case """
26 nat_addr = '10.0.10.3'
37 tcp_external_port = 80
50 def plugin_enable(self):
51 self.vapi.nat44_ed_plugin_enable_disable(
52 sessions=self.max_sessions, enable=1)
54 def plugin_disable(self):
55 self.vapi.nat44_ed_plugin_enable_disable(enable=0)
58 def config_flags(self):
59 return VppEnum.vl_api_nat_config_flags_t
62 def nat44_config_flags(self):
63 return VppEnum.vl_api_nat44_config_flags_t
66 def syslog_severity(self):
67 return VppEnum.vl_api_syslog_severity_t
70 def server_addr(self):
71 return self.pg1.remote_hosts[0].ip4
75 return randint(1025, 65535)
78 def proto2layer(proto):
79 if proto == IP_PROTOS.tcp:
81 elif proto == IP_PROTOS.udp:
83 elif proto == IP_PROTOS.icmp:
86 raise Exception("Unsupported protocol")
89 def create_and_add_ip4_table(cls, i, table_id=0):
90 cls.vapi.ip_table_add_del(is_add=1, table={'table_id': table_id})
91 i.set_table_ip4(table_id)
94 def configure_ip4_interface(cls, i, hosts=0, table_id=None):
96 cls.create_and_add_ip4_table(i, table_id)
103 i.generate_remote_hosts(hosts)
104 i.configure_ipv4_neighbors()
107 def nat_add_interface_address(cls, i):
108 cls.vapi.nat44_add_del_interface_addr(
109 sw_if_index=i.sw_if_index, is_add=1)
111 def nat_add_inside_interface(self, i):
112 self.vapi.nat44_interface_add_del_feature(
113 flags=self.config_flags.NAT_IS_INSIDE,
114 sw_if_index=i.sw_if_index, is_add=1)
116 def nat_add_outside_interface(self, i):
117 self.vapi.nat44_interface_add_del_feature(
118 flags=self.config_flags.NAT_IS_OUTSIDE,
119 sw_if_index=i.sw_if_index, is_add=1)
121 def nat_add_address(self, address, twice_nat=0,
122 vrf_id=0xFFFFFFFF, is_add=1):
123 flags = self.config_flags.NAT_IS_TWICE_NAT if twice_nat else 0
124 self.vapi.nat44_add_del_address_range(first_ip_address=address,
125 last_ip_address=address,
130 def nat_add_static_mapping(self, local_ip, external_ip='0.0.0.0',
131 local_port=0, external_port=0, vrf_id=0,
132 is_add=1, external_sw_if_index=0xFFFFFFFF,
133 proto=0, tag="", flags=0):
135 if not (local_port and external_port):
136 flags |= self.config_flags.NAT_IS_ADDR_ONLY
138 self.vapi.nat44_add_del_static_mapping(
140 local_ip_address=local_ip,
141 external_ip_address=external_ip,
142 external_sw_if_index=external_sw_if_index,
143 local_port=local_port,
144 external_port=external_port,
145 vrf_id=vrf_id, protocol=proto,
153 cls.create_pg_interfaces(range(12))
154 cls.interfaces = list(cls.pg_interfaces[:4])
156 cls.create_and_add_ip4_table(cls.pg2, 10)
158 for i in cls.interfaces:
159 cls.configure_ip4_interface(i, hosts=3)
161 # test specific (test-multiple-vrf)
162 cls.vapi.ip_table_add_del(is_add=1, table={'table_id': 1})
164 # test specific (test-one-armed-nat44-static)
165 cls.pg4.generate_remote_hosts(2)
167 cls.vapi.sw_interface_add_del_address(
168 sw_if_index=cls.pg4.sw_if_index,
169 prefix="10.0.0.1/24")
171 cls.pg4.resolve_arp()
172 cls.pg4._remote_hosts[1]._ip4 = cls.pg4._remote_hosts[0]._ip4
173 cls.pg4.resolve_arp()
175 # test specific interface (pg5)
176 cls.pg5._local_ip4 = "10.1.1.1"
177 cls.pg5._remote_hosts[0]._ip4 = "10.1.1.2"
178 cls.pg5.set_table_ip4(1)
181 cls.pg5.resolve_arp()
183 # test specific interface (pg6)
184 cls.pg6._local_ip4 = "10.1.2.1"
185 cls.pg6._remote_hosts[0]._ip4 = "10.1.2.2"
186 cls.pg6.set_table_ip4(1)
189 cls.pg6.resolve_arp()
193 rl.append(VppIpRoute(cls, "0.0.0.0", 0,
194 [VppRoutePath("0.0.0.0", 0xffffffff,
196 register=False, table_id=1))
197 rl.append(VppIpRoute(cls, "0.0.0.0", 0,
198 [VppRoutePath(cls.pg1.local_ip4,
199 cls.pg1.sw_if_index)],
201 rl.append(VppIpRoute(cls, cls.pg5.remote_ip4, 32,
202 [VppRoutePath("0.0.0.0",
203 cls.pg5.sw_if_index)],
204 register=False, table_id=1))
205 rl.append(VppIpRoute(cls, cls.pg6.remote_ip4, 32,
206 [VppRoutePath("0.0.0.0",
207 cls.pg6.sw_if_index)],
208 register=False, table_id=1))
209 rl.append(VppIpRoute(cls, cls.pg6.remote_ip4, 16,
210 [VppRoutePath("0.0.0.0", 0xffffffff,
212 register=False, table_id=0))
217 cls.no_diff = StatsDiff({
219 '/nat44-ed/in2out/fastpath/tcp': 0,
220 '/nat44-ed/in2out/fastpath/udp': 0,
221 '/nat44-ed/in2out/fastpath/icmp': 0,
222 '/nat44-ed/in2out/fastpath/drops': 0,
223 '/nat44-ed/in2out/slowpath/tcp': 0,
224 '/nat44-ed/in2out/slowpath/udp': 0,
225 '/nat44-ed/in2out/slowpath/icmp': 0,
226 '/nat44-ed/in2out/slowpath/drops': 0,
227 '/nat44-ed/in2out/fastpath/tcp': 0,
228 '/nat44-ed/in2out/fastpath/udp': 0,
229 '/nat44-ed/in2out/fastpath/icmp': 0,
230 '/nat44-ed/in2out/fastpath/drops': 0,
231 '/nat44-ed/in2out/slowpath/tcp': 0,
232 '/nat44-ed/in2out/slowpath/udp': 0,
233 '/nat44-ed/in2out/slowpath/icmp': 0,
234 '/nat44-ed/in2out/slowpath/drops': 0,
236 for pg in cls.pg_interfaces
239 def get_err_counter(self, path):
240 return self.statistics.get_err_counter(path)
242 def reass_hairpinning(self, server_addr, server_in_port, server_out_port,
243 host_in_port, proto=IP_PROTOS.tcp,
245 layer = self.proto2layer(proto)
247 if proto == IP_PROTOS.tcp:
248 data = b"A" * 4 + b"B" * 16 + b"C" * 3
250 data = b"A" * 16 + b"B" * 16 + b"C" * 3
252 # send packet from host to server
253 pkts = self.create_stream_frag(self.pg0,
259 self.pg0.add_stream(pkts)
260 self.pg_enable_capture(self.pg_interfaces)
262 frags = self.pg0.get_capture(len(pkts))
263 p = self.reass_frags_and_verify(frags,
266 if proto != IP_PROTOS.icmp:
268 self.assertNotEqual(p[layer].sport, host_in_port)
269 self.assertEqual(p[layer].dport, server_in_port)
272 self.assertNotEqual(p[layer].id, host_in_port)
273 self.assertEqual(data, p[Raw].load)
275 def frag_out_of_order(self, proto=IP_PROTOS.tcp, dont_translate=False,
277 layer = self.proto2layer(proto)
279 if proto == IP_PROTOS.tcp:
280 data = b"A" * 4 + b"B" * 16 + b"C" * 3
282 data = b"A" * 16 + b"B" * 16 + b"C" * 3
283 self.port_in = self.random_port()
287 pkts = self.create_stream_frag(self.pg0, self.pg1.remote_ip4,
288 self.port_in, 20, data, proto)
290 self.pg0.add_stream(pkts)
291 self.pg_enable_capture(self.pg_interfaces)
293 frags = self.pg1.get_capture(len(pkts))
294 if not dont_translate:
295 p = self.reass_frags_and_verify(frags,
299 p = self.reass_frags_and_verify(frags,
302 if proto != IP_PROTOS.icmp:
303 if not dont_translate:
304 self.assertEqual(p[layer].dport, 20)
306 self.assertNotEqual(p[layer].sport, self.port_in)
308 self.assertEqual(p[layer].sport, self.port_in)
311 if not dont_translate:
312 self.assertNotEqual(p[layer].id, self.port_in)
314 self.assertEqual(p[layer].id, self.port_in)
315 self.assertEqual(data, p[Raw].load)
318 if not dont_translate:
319 dst_addr = self.nat_addr
321 dst_addr = self.pg0.remote_ip4
322 if proto != IP_PROTOS.icmp:
324 dport = p[layer].sport
328 pkts = self.create_stream_frag(self.pg1, dst_addr, sport, dport,
329 data, proto, echo_reply=True)
331 self.pg1.add_stream(pkts)
332 self.pg_enable_capture(self.pg_interfaces)
333 self.logger.info(self.vapi.cli("show trace"))
335 frags = self.pg0.get_capture(len(pkts))
336 p = self.reass_frags_and_verify(frags,
339 if proto != IP_PROTOS.icmp:
340 self.assertEqual(p[layer].sport, 20)
341 self.assertEqual(p[layer].dport, self.port_in)
343 self.assertEqual(p[layer].id, self.port_in)
344 self.assertEqual(data, p[Raw].load)
346 def reass_frags_and_verify(self, frags, src, dst):
349 self.assertEqual(p[IP].src, src)
350 self.assertEqual(p[IP].dst, dst)
351 self.assert_ip_checksum_valid(p)
352 buffer.seek(p[IP].frag * 8)
353 buffer.write(bytes(p[IP].payload))
354 ip = IP(src=frags[0][IP].src, dst=frags[0][IP].dst,
355 proto=frags[0][IP].proto)
356 if ip.proto == IP_PROTOS.tcp:
357 p = (ip / TCP(buffer.getvalue()))
358 self.logger.debug(ppp("Reassembled:", p))
359 self.assert_tcp_checksum_valid(p)
360 elif ip.proto == IP_PROTOS.udp:
361 p = (ip / UDP(buffer.getvalue()[:8]) /
362 Raw(buffer.getvalue()[8:]))
363 elif ip.proto == IP_PROTOS.icmp:
364 p = (ip / ICMP(buffer.getvalue()))
367 def frag_in_order(self, proto=IP_PROTOS.tcp, dont_translate=False,
369 layer = self.proto2layer(proto)
371 if proto == IP_PROTOS.tcp:
372 data = b"A" * 4 + b"B" * 16 + b"C" * 3
374 data = b"A" * 16 + b"B" * 16 + b"C" * 3
375 self.port_in = self.random_port()
378 pkts = self.create_stream_frag(self.pg0, self.pg1.remote_ip4,
379 self.port_in, 20, data, proto)
380 self.pg0.add_stream(pkts)
381 self.pg_enable_capture(self.pg_interfaces)
383 frags = self.pg1.get_capture(len(pkts))
384 if not dont_translate:
385 p = self.reass_frags_and_verify(frags,
389 p = self.reass_frags_and_verify(frags,
392 if proto != IP_PROTOS.icmp:
393 if not dont_translate:
394 self.assertEqual(p[layer].dport, 20)
396 self.assertNotEqual(p[layer].sport, self.port_in)
398 self.assertEqual(p[layer].sport, self.port_in)
401 if not dont_translate:
402 self.assertNotEqual(p[layer].id, self.port_in)
404 self.assertEqual(p[layer].id, self.port_in)
405 self.assertEqual(data, p[Raw].load)
408 if not dont_translate:
409 dst_addr = self.nat_addr
411 dst_addr = self.pg0.remote_ip4
412 if proto != IP_PROTOS.icmp:
414 dport = p[layer].sport
418 pkts = self.create_stream_frag(self.pg1, dst_addr, sport, dport, data,
419 proto, echo_reply=True)
420 self.pg1.add_stream(pkts)
421 self.pg_enable_capture(self.pg_interfaces)
423 frags = self.pg0.get_capture(len(pkts))
424 p = self.reass_frags_and_verify(frags,
427 if proto != IP_PROTOS.icmp:
428 self.assertEqual(p[layer].sport, 20)
429 self.assertEqual(p[layer].dport, self.port_in)
431 self.assertEqual(p[layer].id, self.port_in)
432 self.assertEqual(data, p[Raw].load)
434 def verify_capture_out(self, capture, nat_ip=None, same_port=False,
435 dst_ip=None, ignore_port=False):
437 nat_ip = self.nat_addr
438 for packet in capture:
440 self.assert_packet_checksums_valid(packet)
441 self.assertEqual(packet[IP].src, nat_ip)
442 if dst_ip is not None:
443 self.assertEqual(packet[IP].dst, dst_ip)
444 if packet.haslayer(TCP):
448 packet[TCP].sport, self.tcp_port_in)
451 packet[TCP].sport, self.tcp_port_in)
452 self.tcp_port_out = packet[TCP].sport
453 self.assert_packet_checksums_valid(packet)
454 elif packet.haslayer(UDP):
458 packet[UDP].sport, self.udp_port_in)
461 packet[UDP].sport, self.udp_port_in)
462 self.udp_port_out = packet[UDP].sport
467 packet[ICMP].id, self.icmp_id_in)
470 packet[ICMP].id, self.icmp_id_in)
471 self.icmp_id_out = packet[ICMP].id
472 self.assert_packet_checksums_valid(packet)
474 self.logger.error(ppp("Unexpected or invalid packet "
475 "(outside network):", packet))
478 def verify_capture_in(self, capture, in_if):
479 for packet in capture:
481 self.assert_packet_checksums_valid(packet)
482 self.assertEqual(packet[IP].dst, in_if.remote_ip4)
483 if packet.haslayer(TCP):
484 self.assertEqual(packet[TCP].dport, self.tcp_port_in)
485 elif packet.haslayer(UDP):
486 self.assertEqual(packet[UDP].dport, self.udp_port_in)
488 self.assertEqual(packet[ICMP].id, self.icmp_id_in)
490 self.logger.error(ppp("Unexpected or invalid packet "
491 "(inside network):", packet))
494 def create_stream_in(self, in_if, out_if, dst_ip=None, ttl=64):
496 dst_ip = out_if.remote_ip4
500 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
501 IP(src=in_if.remote_ip4, dst=dst_ip, ttl=ttl) /
502 TCP(sport=self.tcp_port_in, dport=20))
506 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
507 IP(src=in_if.remote_ip4, dst=dst_ip, ttl=ttl) /
508 UDP(sport=self.udp_port_in, dport=20))
512 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
513 IP(src=in_if.remote_ip4, dst=dst_ip, ttl=ttl) /
514 ICMP(id=self.icmp_id_in, type='echo-request'))
519 def create_stream_out(self, out_if, dst_ip=None, ttl=64,
520 use_inside_ports=False):
522 dst_ip = self.nat_addr
523 if not use_inside_ports:
524 tcp_port = self.tcp_port_out
525 udp_port = self.udp_port_out
526 icmp_id = self.icmp_id_out
528 tcp_port = self.tcp_port_in
529 udp_port = self.udp_port_in
530 icmp_id = self.icmp_id_in
533 p = (Ether(dst=out_if.local_mac, src=out_if.remote_mac) /
534 IP(src=out_if.remote_ip4, dst=dst_ip, ttl=ttl) /
535 TCP(dport=tcp_port, sport=20))
539 p = (Ether(dst=out_if.local_mac, src=out_if.remote_mac) /
540 IP(src=out_if.remote_ip4, dst=dst_ip, ttl=ttl) /
541 UDP(dport=udp_port, sport=20))
545 p = (Ether(dst=out_if.local_mac, src=out_if.remote_mac) /
546 IP(src=out_if.remote_ip4, dst=dst_ip, ttl=ttl) /
547 ICMP(id=icmp_id, type='echo-reply'))
552 def create_tcp_stream(self, in_if, out_if, count):
556 for i in range(count):
557 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
558 IP(src=in_if.remote_ip4, dst=out_if.remote_ip4, ttl=64) /
559 TCP(sport=port + i, dport=20))
564 def create_stream_frag(self, src_if, dst, sport, dport, data,
565 proto=IP_PROTOS.tcp, echo_reply=False):
566 if proto == IP_PROTOS.tcp:
567 p = (IP(src=src_if.remote_ip4, dst=dst) /
568 TCP(sport=sport, dport=dport) /
570 p = p.__class__(scapy.compat.raw(p))
571 chksum = p[TCP].chksum
572 proto_header = TCP(sport=sport, dport=dport, chksum=chksum)
573 elif proto == IP_PROTOS.udp:
574 proto_header = UDP(sport=sport, dport=dport)
575 elif proto == IP_PROTOS.icmp:
577 proto_header = ICMP(id=sport, type='echo-request')
579 proto_header = ICMP(id=sport, type='echo-reply')
581 raise Exception("Unsupported protocol")
582 id = self.random_port()
584 if proto == IP_PROTOS.tcp:
587 raw = Raw(data[0:16])
588 p = (Ether(src=src_if.remote_mac, dst=src_if.local_mac) /
589 IP(src=src_if.remote_ip4, dst=dst, flags="MF", frag=0, id=id) /
593 if proto == IP_PROTOS.tcp:
594 raw = Raw(data[4:20])
596 raw = Raw(data[16:32])
597 p = (Ether(src=src_if.remote_mac, dst=src_if.local_mac) /
598 IP(src=src_if.remote_ip4, dst=dst, flags="MF", frag=3, id=id,
602 if proto == IP_PROTOS.tcp:
606 p = (Ether(src=src_if.remote_mac, dst=src_if.local_mac) /
607 IP(src=src_if.remote_ip4, dst=dst, frag=5, proto=proto,
613 def frag_in_order_in_plus_out(self, in_addr, out_addr, in_port, out_port,
614 proto=IP_PROTOS.tcp):
616 layer = self.proto2layer(proto)
618 if proto == IP_PROTOS.tcp:
619 data = b"A" * 4 + b"B" * 16 + b"C" * 3
621 data = b"A" * 16 + b"B" * 16 + b"C" * 3
622 port_in = self.random_port()
626 pkts = self.create_stream_frag(self.pg0, out_addr,
629 self.pg0.add_stream(pkts)
630 self.pg_enable_capture(self.pg_interfaces)
632 frags = self.pg1.get_capture(len(pkts))
633 p = self.reass_frags_and_verify(frags,
636 if proto != IP_PROTOS.icmp:
637 self.assertEqual(p[layer].sport, port_in)
638 self.assertEqual(p[layer].dport, in_port)
640 self.assertEqual(p[layer].id, port_in)
641 self.assertEqual(data, p[Raw].load)
644 if proto != IP_PROTOS.icmp:
645 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
647 p[layer].sport, data, proto)
649 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
650 p[layer].id, 0, data, proto,
652 self.pg1.add_stream(pkts)
653 self.pg_enable_capture(self.pg_interfaces)
655 frags = self.pg0.get_capture(len(pkts))
656 p = self.reass_frags_and_verify(frags,
659 if proto != IP_PROTOS.icmp:
660 self.assertEqual(p[layer].sport, out_port)
661 self.assertEqual(p[layer].dport, port_in)
663 self.assertEqual(p[layer].id, port_in)
664 self.assertEqual(data, p[Raw].load)
666 def frag_out_of_order_in_plus_out(self, in_addr, out_addr, in_port,
667 out_port, proto=IP_PROTOS.tcp):
669 layer = self.proto2layer(proto)
671 if proto == IP_PROTOS.tcp:
672 data = b"A" * 4 + b"B" * 16 + b"C" * 3
674 data = b"A" * 16 + b"B" * 16 + b"C" * 3
675 port_in = self.random_port()
679 pkts = self.create_stream_frag(self.pg0, out_addr,
683 self.pg0.add_stream(pkts)
684 self.pg_enable_capture(self.pg_interfaces)
686 frags = self.pg1.get_capture(len(pkts))
687 p = self.reass_frags_and_verify(frags,
690 if proto != IP_PROTOS.icmp:
691 self.assertEqual(p[layer].dport, in_port)
692 self.assertEqual(p[layer].sport, port_in)
693 self.assertEqual(p[layer].dport, in_port)
695 self.assertEqual(p[layer].id, port_in)
696 self.assertEqual(data, p[Raw].load)
699 if proto != IP_PROTOS.icmp:
700 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
702 p[layer].sport, data, proto)
704 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
705 p[layer].id, 0, data, proto,
708 self.pg1.add_stream(pkts)
709 self.pg_enable_capture(self.pg_interfaces)
711 frags = self.pg0.get_capture(len(pkts))
712 p = self.reass_frags_and_verify(frags,
715 if proto != IP_PROTOS.icmp:
716 self.assertEqual(p[layer].sport, out_port)
717 self.assertEqual(p[layer].dport, port_in)
719 self.assertEqual(p[layer].id, port_in)
720 self.assertEqual(data, p[Raw].load)
722 def init_tcp_session(self, in_if, out_if, in_port, ext_port):
724 p = (Ether(src=in_if.remote_mac, dst=in_if.local_mac) /
725 IP(src=in_if.remote_ip4, dst=out_if.remote_ip4) /
726 TCP(sport=in_port, dport=ext_port, flags="S"))
728 self.pg_enable_capture(self.pg_interfaces)
730 capture = out_if.get_capture(1)
732 out_port = p[TCP].sport
734 # SYN + ACK packet out->in
735 p = (Ether(src=out_if.remote_mac, dst=out_if.local_mac) /
736 IP(src=out_if.remote_ip4, dst=self.nat_addr) /
737 TCP(sport=ext_port, dport=out_port, flags="SA"))
739 self.pg_enable_capture(self.pg_interfaces)
744 p = (Ether(src=in_if.remote_mac, dst=in_if.local_mac) /
745 IP(src=in_if.remote_ip4, dst=out_if.remote_ip4) /
746 TCP(sport=in_port, dport=ext_port, flags="A"))
748 self.pg_enable_capture(self.pg_interfaces)
750 out_if.get_capture(1)
754 def twice_nat_common(self, self_twice_nat=False, same_pg=False, lb=False,
756 twice_nat_addr = '10.0.1.3'
764 port_in1 = port_in + 1
765 port_in2 = port_in + 2
770 server1 = self.pg0.remote_hosts[0]
771 server2 = self.pg0.remote_hosts[1]
783 eh_translate = ((not self_twice_nat) or (not lb and same_pg) or
786 self.nat_add_address(self.nat_addr)
787 self.nat_add_address(twice_nat_addr, twice_nat=1)
791 flags |= self.config_flags.NAT_IS_SELF_TWICE_NAT
793 flags |= self.config_flags.NAT_IS_TWICE_NAT
796 self.nat_add_static_mapping(pg0.remote_ip4, self.nat_addr,
801 locals = [{'addr': server1.ip4,
805 {'addr': server2.ip4,
809 out_addr = self.nat_addr
811 self.vapi.nat44_add_del_lb_static_mapping(is_add=1, flags=flags,
812 external_addr=out_addr,
813 external_port=port_out,
814 protocol=IP_PROTOS.tcp,
815 local_num=len(locals),
817 self.nat_add_inside_interface(pg0)
818 self.nat_add_outside_interface(pg1)
824 assert client_id is not None
826 client = self.pg0.remote_hosts[0]
828 client = self.pg0.remote_hosts[1]
830 client = pg1.remote_hosts[0]
831 p = (Ether(src=pg1.remote_mac, dst=pg1.local_mac) /
832 IP(src=client.ip4, dst=self.nat_addr) /
833 TCP(sport=eh_port_out, dport=port_out))
835 self.pg_enable_capture(self.pg_interfaces)
837 capture = pg0.get_capture(1)
843 if ip.dst == server1.ip4:
849 self.assertEqual(ip.dst, server.ip4)
851 self.assertIn(tcp.dport, [port_in1, port_in2])
853 self.assertEqual(tcp.dport, port_in)
855 self.assertEqual(ip.src, twice_nat_addr)
856 self.assertNotEqual(tcp.sport, eh_port_out)
858 self.assertEqual(ip.src, client.ip4)
859 self.assertEqual(tcp.sport, eh_port_out)
861 eh_port_in = tcp.sport
862 saved_port_in = tcp.dport
863 self.assert_packet_checksums_valid(p)
865 self.logger.error(ppp("Unexpected or invalid packet:", p))
868 p = (Ether(src=server.mac, dst=pg0.local_mac) /
869 IP(src=server.ip4, dst=eh_addr_in) /
870 TCP(sport=saved_port_in, dport=eh_port_in))
872 self.pg_enable_capture(self.pg_interfaces)
874 capture = pg1.get_capture(1)
879 self.assertEqual(ip.dst, client.ip4)
880 self.assertEqual(ip.src, self.nat_addr)
881 self.assertEqual(tcp.dport, eh_port_out)
882 self.assertEqual(tcp.sport, port_out)
883 self.assert_packet_checksums_valid(p)
885 self.logger.error(ppp("Unexpected or invalid packet:", p))
889 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
890 self.assertEqual(len(sessions), 1)
891 self.assertTrue(sessions[0].flags &
892 self.config_flags.NAT_IS_EXT_HOST_VALID)
893 self.assertTrue(sessions[0].flags &
894 self.config_flags.NAT_IS_TWICE_NAT)
895 self.logger.info(self.vapi.cli("show nat44 sessions"))
896 self.vapi.nat44_del_session(
897 address=sessions[0].inside_ip_address,
898 port=sessions[0].inside_port,
899 protocol=sessions[0].protocol,
900 flags=(self.config_flags.NAT_IS_INSIDE |
901 self.config_flags.NAT_IS_EXT_HOST_VALID),
902 ext_host_address=sessions[0].ext_host_nat_address,
903 ext_host_port=sessions[0].ext_host_nat_port)
904 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
905 self.assertEqual(len(sessions), 0)
907 def verify_syslog_sess(self, data, msgid, is_ip6=False):
908 message = data.decode('utf-8')
910 message = SyslogMessage.parse(message)
911 except ParseError as e:
915 self.assertEqual(message.severity, SyslogSeverity.info)
916 self.assertEqual(message.appname, 'NAT')
917 self.assertEqual(message.msgid, msgid)
918 sd_params = message.sd.get('nsess')
919 self.assertTrue(sd_params is not None)
921 self.assertEqual(sd_params.get('IATYP'), 'IPv6')
922 self.assertEqual(sd_params.get('ISADDR'), self.pg0.remote_ip6)
924 self.assertEqual(sd_params.get('IATYP'), 'IPv4')
925 self.assertEqual(sd_params.get('ISADDR'), self.pg0.remote_ip4)
926 self.assertTrue(sd_params.get('SSUBIX') is not None)
927 self.assertEqual(sd_params.get('ISPORT'), "%d" % self.tcp_port_in)
928 self.assertEqual(sd_params.get('XATYP'), 'IPv4')
929 self.assertEqual(sd_params.get('XSADDR'), self.nat_addr)
930 self.assertEqual(sd_params.get('XSPORT'), "%d" % self.tcp_port_out)
931 self.assertEqual(sd_params.get('PROTO'), "%d" % IP_PROTOS.tcp)
932 self.assertEqual(sd_params.get('SVLAN'), '0')
933 self.assertEqual(sd_params.get('XDADDR'), self.pg1.remote_ip4)
934 self.assertEqual(sd_params.get('XDPORT'),
935 "%d" % self.tcp_external_port)
937 def test_icmp_error(self):
938 """ NAT44ED test ICMP error message with inner header"""
942 self.nat_add_address(self.nat_addr)
943 self.nat_add_inside_interface(self.pg0)
944 self.nat_add_outside_interface(self.pg1)
946 # in2out (initiate connection)
947 p1 = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
948 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
949 UDP(sport=21, dport=20) / payload)
951 self.pg0.add_stream(p1)
952 self.pg_enable_capture(self.pg_interfaces)
954 capture = self.pg1.get_capture(1)[0]
956 # out2in (send error message)
957 p2 = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
958 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
959 ICMP(type='dest-unreach', code='port-unreachable') /
962 self.pg1.add_stream(p2)
963 self.pg_enable_capture(self.pg_interfaces)
966 capture = self.pg0.get_capture(1)[0]
968 self.logger.info(ppp("p1 packet:", p1))
969 self.logger.info(ppp("p2 packet:", p2))
970 self.logger.info(ppp("capture packet:", capture))
972 def test_icmp_echo_reply_trailer(self):
973 """ ICMP echo reply with ethernet trailer"""
975 self.nat_add_address(self.nat_addr)
976 self.nat_add_inside_interface(self.pg0)
977 self.nat_add_outside_interface(self.pg1)
980 p1 = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
981 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
982 ICMP(type=8, id=0xabcd, seq=0))
984 self.pg0.add_stream(p1)
985 self.pg_enable_capture(self.pg_interfaces)
987 c = self.pg1.get_capture(1)[0]
989 self.logger.debug(self.vapi.cli("show trace"))
992 p2 = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
993 IP(src=self.pg1.remote_ip4, dst=self.nat_addr, id=0xee59) /
994 ICMP(type=0, id=c[ICMP].id, seq=0))
996 # force checksum calculation
997 p2 = p2.__class__(bytes(p2))
999 self.logger.debug(ppp("Packet before modification:", p2))
1001 # hex representation of vss monitoring ethernet trailer
1002 # this seems to be just added to end of packet without modifying
1003 # IP or ICMP lengths / checksums
1004 p2 = p2 / Raw("\x00\x00\x52\x54\x00\x46\xab\x04\x84\x18")
1005 # change it so that IP/ICMP is unaffected
1008 self.logger.debug(ppp("Packet with added trailer:", p2))
1010 self.pg1.add_stream(p2)
1011 self.pg_enable_capture(self.pg_interfaces)
1014 self.pg0.get_capture(1)
1016 def test_users_dump(self):
1017 """ NAT44ED API test - nat44_user_dump """
1019 self.nat_add_address(self.nat_addr)
1020 self.nat_add_inside_interface(self.pg0)
1021 self.nat_add_outside_interface(self.pg1)
1023 self.vapi.nat44_forwarding_enable_disable(enable=1)
1025 local_ip = self.pg0.remote_ip4
1026 external_ip = self.nat_addr
1027 self.nat_add_static_mapping(local_ip, external_ip)
1029 users = self.vapi.nat44_user_dump()
1030 self.assertEqual(len(users), 0)
1032 # in2out - static mapping match
1034 pkts = self.create_stream_out(self.pg1)
1035 self.pg1.add_stream(pkts)
1036 self.pg_enable_capture(self.pg_interfaces)
1038 capture = self.pg0.get_capture(len(pkts))
1039 self.verify_capture_in(capture, self.pg0)
1041 pkts = self.create_stream_in(self.pg0, self.pg1)
1042 self.pg0.add_stream(pkts)
1043 self.pg_enable_capture(self.pg_interfaces)
1045 capture = self.pg1.get_capture(len(pkts))
1046 self.verify_capture_out(capture, same_port=True)
1048 users = self.vapi.nat44_user_dump()
1049 self.assertEqual(len(users), 1)
1050 static_user = users[0]
1051 self.assertEqual(static_user.nstaticsessions, 3)
1052 self.assertEqual(static_user.nsessions, 0)
1054 # in2out - no static mapping match (forwarding test)
1056 host0 = self.pg0.remote_hosts[0]
1057 self.pg0.remote_hosts[0] = self.pg0.remote_hosts[1]
1059 pkts = self.create_stream_out(self.pg1,
1060 dst_ip=self.pg0.remote_ip4,
1061 use_inside_ports=True)
1062 self.pg1.add_stream(pkts)
1063 self.pg_enable_capture(self.pg_interfaces)
1065 capture = self.pg0.get_capture(len(pkts))
1066 self.verify_capture_in(capture, self.pg0)
1068 pkts = self.create_stream_in(self.pg0, self.pg1)
1069 self.pg0.add_stream(pkts)
1070 self.pg_enable_capture(self.pg_interfaces)
1072 capture = self.pg1.get_capture(len(pkts))
1073 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
1076 self.pg0.remote_hosts[0] = host0
1078 users = self.vapi.nat44_user_dump()
1079 self.assertEqual(len(users), 2)
1080 if str(users[0].ip_address) == self.pg0.remote_hosts[0].ip4:
1081 non_static_user = users[1]
1082 static_user = users[0]
1084 non_static_user = users[0]
1085 static_user = users[1]
1086 self.assertEqual(static_user.nstaticsessions, 3)
1087 self.assertEqual(static_user.nsessions, 0)
1088 self.assertEqual(non_static_user.nstaticsessions, 0)
1089 self.assertEqual(non_static_user.nsessions, 3)
1091 users = self.vapi.nat44_user_dump()
1092 self.assertEqual(len(users), 2)
1093 if str(users[0].ip_address) == self.pg0.remote_hosts[0].ip4:
1094 non_static_user = users[1]
1095 static_user = users[0]
1097 non_static_user = users[0]
1098 static_user = users[1]
1099 self.assertEqual(static_user.nstaticsessions, 3)
1100 self.assertEqual(static_user.nsessions, 0)
1101 self.assertEqual(non_static_user.nstaticsessions, 0)
1102 self.assertEqual(non_static_user.nsessions, 3)
1104 def test_frag_out_of_order_do_not_translate(self):
1105 """ NAT44ED don't translate fragments arriving out of order """
1106 self.nat_add_inside_interface(self.pg0)
1107 self.nat_add_outside_interface(self.pg1)
1108 self.vapi.nat44_forwarding_enable_disable(enable=True)
1109 self.frag_out_of_order(proto=IP_PROTOS.tcp, dont_translate=True)
1111 def test_forwarding(self):
1112 """ NAT44ED forwarding test """
1114 self.nat_add_inside_interface(self.pg0)
1115 self.nat_add_outside_interface(self.pg1)
1116 self.vapi.nat44_forwarding_enable_disable(enable=1)
1118 real_ip = self.pg0.remote_ip4
1119 alias_ip = self.nat_addr
1120 flags = self.config_flags.NAT_IS_ADDR_ONLY
1121 self.vapi.nat44_add_del_static_mapping(is_add=1,
1122 local_ip_address=real_ip,
1123 external_ip_address=alias_ip,
1124 external_sw_if_index=0xFFFFFFFF,
1128 # in2out - static mapping match
1130 pkts = self.create_stream_out(self.pg1)
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, same_port=True)
1144 # in2out - no static mapping match
1146 host0 = self.pg0.remote_hosts[0]
1147 self.pg0.remote_hosts[0] = self.pg0.remote_hosts[1]
1149 pkts = self.create_stream_out(self.pg1,
1150 dst_ip=self.pg0.remote_ip4,
1151 use_inside_ports=True)
1152 self.pg1.add_stream(pkts)
1153 self.pg_enable_capture(self.pg_interfaces)
1155 capture = self.pg0.get_capture(len(pkts))
1156 self.verify_capture_in(capture, self.pg0)
1158 pkts = self.create_stream_in(self.pg0, self.pg1)
1159 self.pg0.add_stream(pkts)
1160 self.pg_enable_capture(self.pg_interfaces)
1162 capture = self.pg1.get_capture(len(pkts))
1163 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
1166 self.pg0.remote_hosts[0] = host0
1168 user = self.pg0.remote_hosts[1]
1169 sessions = self.vapi.nat44_user_session_dump(user.ip4, 0)
1170 self.assertEqual(len(sessions), 3)
1171 self.assertTrue(sessions[0].flags &
1172 self.config_flags.NAT_IS_EXT_HOST_VALID)
1173 self.vapi.nat44_del_session(
1174 address=sessions[0].inside_ip_address,
1175 port=sessions[0].inside_port,
1176 protocol=sessions[0].protocol,
1177 flags=(self.config_flags.NAT_IS_INSIDE |
1178 self.config_flags.NAT_IS_EXT_HOST_VALID),
1179 ext_host_address=sessions[0].ext_host_address,
1180 ext_host_port=sessions[0].ext_host_port)
1181 sessions = self.vapi.nat44_user_session_dump(user.ip4, 0)
1182 self.assertEqual(len(sessions), 2)
1185 self.vapi.nat44_forwarding_enable_disable(enable=0)
1186 flags = self.config_flags.NAT_IS_ADDR_ONLY
1187 self.vapi.nat44_add_del_static_mapping(
1189 local_ip_address=real_ip,
1190 external_ip_address=alias_ip,
1191 external_sw_if_index=0xFFFFFFFF,
1194 def test_output_feature_and_service2(self):
1195 """ NAT44ED interface output feature and service host direct access """
1196 self.vapi.nat44_forwarding_enable_disable(enable=1)
1197 self.nat_add_address(self.nat_addr)
1199 self.vapi.nat44_interface_add_del_output_feature(
1200 sw_if_index=self.pg1.sw_if_index, is_add=1,)
1202 # session initiated from service host - translate
1203 pkts = self.create_stream_in(self.pg0, self.pg1)
1204 self.pg0.add_stream(pkts)
1205 self.pg_enable_capture(self.pg_interfaces)
1207 capture = self.pg1.get_capture(len(pkts))
1208 self.verify_capture_out(capture, ignore_port=True)
1210 pkts = self.create_stream_out(self.pg1)
1211 self.pg1.add_stream(pkts)
1212 self.pg_enable_capture(self.pg_interfaces)
1214 capture = self.pg0.get_capture(len(pkts))
1215 self.verify_capture_in(capture, self.pg0)
1217 # session initiated from remote host - do not translate
1218 tcp_port_in = self.tcp_port_in
1219 udp_port_in = self.udp_port_in
1220 icmp_id_in = self.icmp_id_in
1222 self.tcp_port_in = 60303
1223 self.udp_port_in = 60304
1224 self.icmp_id_in = 60305
1227 pkts = self.create_stream_out(self.pg1,
1228 self.pg0.remote_ip4,
1229 use_inside_ports=True)
1230 self.pg1.add_stream(pkts)
1231 self.pg_enable_capture(self.pg_interfaces)
1233 capture = self.pg0.get_capture(len(pkts))
1234 self.verify_capture_in(capture, self.pg0)
1236 pkts = self.create_stream_in(self.pg0, self.pg1)
1237 self.pg0.add_stream(pkts)
1238 self.pg_enable_capture(self.pg_interfaces)
1240 capture = self.pg1.get_capture(len(pkts))
1241 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
1244 self.tcp_port_in = tcp_port_in
1245 self.udp_port_in = udp_port_in
1246 self.icmp_id_in = icmp_id_in
1248 def test_twice_nat(self):
1249 """ NAT44ED Twice NAT """
1250 self.twice_nat_common()
1252 def test_self_twice_nat_positive(self):
1253 """ NAT44ED Self Twice NAT (positive test) """
1254 self.twice_nat_common(self_twice_nat=True, same_pg=True)
1256 def test_self_twice_nat_lb_positive(self):
1257 """ NAT44ED Self Twice NAT local service load balancing (positive test)
1259 self.twice_nat_common(lb=True, self_twice_nat=True, same_pg=True,
1262 def test_twice_nat_lb(self):
1263 """ NAT44ED Twice NAT local service load balancing """
1264 self.twice_nat_common(lb=True)
1266 def test_output_feature(self):
1267 """ NAT44ED interface output feature (in2out postrouting) """
1268 self.vapi.nat44_forwarding_enable_disable(enable=1)
1269 self.nat_add_address(self.nat_addr)
1271 self.nat_add_outside_interface(self.pg0)
1272 self.vapi.nat44_interface_add_del_output_feature(
1273 sw_if_index=self.pg1.sw_if_index, is_add=1)
1276 pkts = self.create_stream_in(self.pg0, self.pg1)
1277 self.pg0.add_stream(pkts)
1278 self.pg_enable_capture(self.pg_interfaces)
1280 capture = self.pg1.get_capture(len(pkts))
1281 self.verify_capture_out(capture, ignore_port=True)
1282 self.logger.debug(self.vapi.cli("show trace"))
1285 pkts = self.create_stream_out(self.pg1)
1286 self.pg1.add_stream(pkts)
1287 self.pg_enable_capture(self.pg_interfaces)
1289 capture = self.pg0.get_capture(len(pkts))
1290 self.verify_capture_in(capture, self.pg0)
1291 self.logger.debug(self.vapi.cli("show trace"))
1294 pkts = self.create_stream_in(self.pg0, self.pg1, ttl=2)
1295 self.pg0.add_stream(pkts)
1296 self.pg_enable_capture(self.pg_interfaces)
1298 capture = self.pg1.get_capture(len(pkts))
1299 self.verify_capture_out(capture, ignore_port=True)
1300 self.logger.debug(self.vapi.cli("show trace"))
1303 pkts = self.create_stream_out(self.pg1, ttl=2)
1304 self.pg1.add_stream(pkts)
1305 self.pg_enable_capture(self.pg_interfaces)
1307 capture = self.pg0.get_capture(len(pkts))
1308 self.verify_capture_in(capture, self.pg0)
1309 self.logger.debug(self.vapi.cli("show trace"))
1312 pkts = self.create_stream_in(self.pg0, self.pg1, ttl=1)
1313 self.pg0.add_stream(pkts)
1314 self.pg_enable_capture(self.pg_interfaces)
1316 capture = self.pg0.get_capture(len(pkts))
1318 self.assertIn(ICMP, p)
1319 self.assertEqual(p[ICMP].type, 11) # 11 == time-exceeded
1321 def test_static_with_port_out2(self):
1322 """ NAT44ED 1:1 NAPT asymmetrical rule """
1327 self.vapi.nat44_forwarding_enable_disable(enable=1)
1328 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1329 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
1330 local_port, external_port,
1331 proto=IP_PROTOS.tcp, flags=flags)
1333 self.nat_add_inside_interface(self.pg0)
1334 self.nat_add_outside_interface(self.pg1)
1336 # from client to service
1337 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1338 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1339 TCP(sport=12345, dport=external_port))
1340 self.pg1.add_stream(p)
1341 self.pg_enable_capture(self.pg_interfaces)
1343 capture = self.pg0.get_capture(1)
1348 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1349 self.assertEqual(tcp.dport, local_port)
1350 self.assert_packet_checksums_valid(p)
1352 self.logger.error(ppp("Unexpected or invalid packet:", p))
1356 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
1357 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1358 ICMP(type=11) / capture[0][IP])
1359 self.pg0.add_stream(p)
1360 self.pg_enable_capture(self.pg_interfaces)
1362 capture = self.pg1.get_capture(1)
1365 self.assertEqual(p[IP].src, self.nat_addr)
1367 self.assertEqual(inner.dst, self.nat_addr)
1368 self.assertEqual(inner[TCPerror].dport, external_port)
1370 self.logger.error(ppp("Unexpected or invalid packet:", p))
1373 # from service back to client
1374 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1375 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1376 TCP(sport=local_port, dport=12345))
1377 self.pg0.add_stream(p)
1378 self.pg_enable_capture(self.pg_interfaces)
1380 capture = self.pg1.get_capture(1)
1385 self.assertEqual(ip.src, self.nat_addr)
1386 self.assertEqual(tcp.sport, external_port)
1387 self.assert_packet_checksums_valid(p)
1389 self.logger.error(ppp("Unexpected or invalid packet:", p))
1393 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1394 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1395 ICMP(type=11) / capture[0][IP])
1396 self.pg1.add_stream(p)
1397 self.pg_enable_capture(self.pg_interfaces)
1399 capture = self.pg0.get_capture(1)
1402 self.assertEqual(p[IP].dst, self.pg0.remote_ip4)
1404 self.assertEqual(inner.src, self.pg0.remote_ip4)
1405 self.assertEqual(inner[TCPerror].sport, local_port)
1407 self.logger.error(ppp("Unexpected or invalid packet:", p))
1410 # from client to server (no translation)
1411 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1412 IP(src=self.pg1.remote_ip4, dst=self.pg0.remote_ip4) /
1413 TCP(sport=12346, dport=local_port))
1414 self.pg1.add_stream(p)
1415 self.pg_enable_capture(self.pg_interfaces)
1417 capture = self.pg0.get_capture(1)
1422 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1423 self.assertEqual(tcp.dport, local_port)
1424 self.assert_packet_checksums_valid(p)
1426 self.logger.error(ppp("Unexpected or invalid packet:", p))
1429 # from service back to client (no translation)
1430 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1431 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1432 TCP(sport=local_port, dport=12346))
1433 self.pg0.add_stream(p)
1434 self.pg_enable_capture(self.pg_interfaces)
1436 capture = self.pg1.get_capture(1)
1441 self.assertEqual(ip.src, self.pg0.remote_ip4)
1442 self.assertEqual(tcp.sport, local_port)
1443 self.assert_packet_checksums_valid(p)
1445 self.logger.error(ppp("Unexpected or invalid packet:", p))
1448 def test_static_lb(self):
1449 """ NAT44ED local service load balancing """
1450 external_addr_n = self.nat_addr
1453 server1 = self.pg0.remote_hosts[0]
1454 server2 = self.pg0.remote_hosts[1]
1456 locals = [{'addr': server1.ip4,
1460 {'addr': server2.ip4,
1465 self.nat_add_address(self.nat_addr)
1466 self.vapi.nat44_add_del_lb_static_mapping(
1468 external_addr=external_addr_n,
1469 external_port=external_port,
1470 protocol=IP_PROTOS.tcp,
1471 local_num=len(locals),
1473 flags = self.config_flags.NAT_IS_INSIDE
1474 self.vapi.nat44_interface_add_del_feature(
1475 sw_if_index=self.pg0.sw_if_index,
1476 flags=flags, is_add=1)
1477 self.vapi.nat44_interface_add_del_feature(
1478 sw_if_index=self.pg1.sw_if_index,
1481 # from client to service
1482 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1483 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1484 TCP(sport=12345, dport=external_port))
1485 self.pg1.add_stream(p)
1486 self.pg_enable_capture(self.pg_interfaces)
1488 capture = self.pg0.get_capture(1)
1494 self.assertIn(ip.dst, [server1.ip4, server2.ip4])
1495 if ip.dst == server1.ip4:
1499 self.assertEqual(tcp.dport, local_port)
1500 self.assert_packet_checksums_valid(p)
1502 self.logger.error(ppp("Unexpected or invalid packet:", p))
1505 # from service back to client
1506 p = (Ether(src=server.mac, dst=self.pg0.local_mac) /
1507 IP(src=server.ip4, dst=self.pg1.remote_ip4) /
1508 TCP(sport=local_port, dport=12345))
1509 self.pg0.add_stream(p)
1510 self.pg_enable_capture(self.pg_interfaces)
1512 capture = self.pg1.get_capture(1)
1517 self.assertEqual(ip.src, self.nat_addr)
1518 self.assertEqual(tcp.sport, external_port)
1519 self.assert_packet_checksums_valid(p)
1521 self.logger.error(ppp("Unexpected or invalid packet:", p))
1524 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
1525 self.assertEqual(len(sessions), 1)
1526 self.assertTrue(sessions[0].flags &
1527 self.config_flags.NAT_IS_EXT_HOST_VALID)
1528 self.vapi.nat44_del_session(
1529 address=sessions[0].inside_ip_address,
1530 port=sessions[0].inside_port,
1531 protocol=sessions[0].protocol,
1532 flags=(self.config_flags.NAT_IS_INSIDE |
1533 self.config_flags.NAT_IS_EXT_HOST_VALID),
1534 ext_host_address=sessions[0].ext_host_address,
1535 ext_host_port=sessions[0].ext_host_port)
1536 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
1537 self.assertEqual(len(sessions), 0)
1539 def test_static_lb_2(self):
1540 """ NAT44ED local service load balancing (asymmetrical rule) """
1541 external_addr = self.nat_addr
1544 server1 = self.pg0.remote_hosts[0]
1545 server2 = self.pg0.remote_hosts[1]
1547 locals = [{'addr': server1.ip4,
1551 {'addr': server2.ip4,
1556 self.vapi.nat44_forwarding_enable_disable(enable=1)
1557 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1558 self.vapi.nat44_add_del_lb_static_mapping(is_add=1, flags=flags,
1559 external_addr=external_addr,
1560 external_port=external_port,
1561 protocol=IP_PROTOS.tcp,
1562 local_num=len(locals),
1564 flags = self.config_flags.NAT_IS_INSIDE
1565 self.vapi.nat44_interface_add_del_feature(
1566 sw_if_index=self.pg0.sw_if_index,
1567 flags=flags, is_add=1)
1568 self.vapi.nat44_interface_add_del_feature(
1569 sw_if_index=self.pg1.sw_if_index,
1572 # from client to service
1573 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1574 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1575 TCP(sport=12345, dport=external_port))
1576 self.pg1.add_stream(p)
1577 self.pg_enable_capture(self.pg_interfaces)
1579 capture = self.pg0.get_capture(1)
1585 self.assertIn(ip.dst, [server1.ip4, server2.ip4])
1586 if ip.dst == server1.ip4:
1590 self.assertEqual(tcp.dport, local_port)
1591 self.assert_packet_checksums_valid(p)
1593 self.logger.error(ppp("Unexpected or invalid packet:", p))
1596 # from service back to client
1597 p = (Ether(src=server.mac, dst=self.pg0.local_mac) /
1598 IP(src=server.ip4, dst=self.pg1.remote_ip4) /
1599 TCP(sport=local_port, dport=12345))
1600 self.pg0.add_stream(p)
1601 self.pg_enable_capture(self.pg_interfaces)
1603 capture = self.pg1.get_capture(1)
1608 self.assertEqual(ip.src, self.nat_addr)
1609 self.assertEqual(tcp.sport, external_port)
1610 self.assert_packet_checksums_valid(p)
1612 self.logger.error(ppp("Unexpected or invalid packet:", p))
1615 # from client to server (no translation)
1616 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1617 IP(src=self.pg1.remote_ip4, dst=server1.ip4) /
1618 TCP(sport=12346, dport=local_port))
1619 self.pg1.add_stream(p)
1620 self.pg_enable_capture(self.pg_interfaces)
1622 capture = self.pg0.get_capture(1)
1628 self.assertEqual(ip.dst, server1.ip4)
1629 self.assertEqual(tcp.dport, local_port)
1630 self.assert_packet_checksums_valid(p)
1632 self.logger.error(ppp("Unexpected or invalid packet:", p))
1635 # from service back to client (no translation)
1636 p = (Ether(src=server1.mac, dst=self.pg0.local_mac) /
1637 IP(src=server1.ip4, dst=self.pg1.remote_ip4) /
1638 TCP(sport=local_port, dport=12346))
1639 self.pg0.add_stream(p)
1640 self.pg_enable_capture(self.pg_interfaces)
1642 capture = self.pg1.get_capture(1)
1647 self.assertEqual(ip.src, server1.ip4)
1648 self.assertEqual(tcp.sport, local_port)
1649 self.assert_packet_checksums_valid(p)
1651 self.logger.error(ppp("Unexpected or invalid packet:", p))
1654 def test_lb_affinity(self):
1655 """ NAT44ED local service load balancing affinity """
1656 external_addr = self.nat_addr
1659 server1 = self.pg0.remote_hosts[0]
1660 server2 = self.pg0.remote_hosts[1]
1662 locals = [{'addr': server1.ip4,
1666 {'addr': server2.ip4,
1671 self.nat_add_address(self.nat_addr)
1672 self.vapi.nat44_add_del_lb_static_mapping(is_add=1,
1673 external_addr=external_addr,
1674 external_port=external_port,
1675 protocol=IP_PROTOS.tcp,
1677 local_num=len(locals),
1679 flags = self.config_flags.NAT_IS_INSIDE
1680 self.vapi.nat44_interface_add_del_feature(
1681 sw_if_index=self.pg0.sw_if_index,
1682 flags=flags, is_add=1)
1683 self.vapi.nat44_interface_add_del_feature(
1684 sw_if_index=self.pg1.sw_if_index,
1687 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1688 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1689 TCP(sport=1025, dport=external_port))
1690 self.pg1.add_stream(p)
1691 self.pg_enable_capture(self.pg_interfaces)
1693 capture = self.pg0.get_capture(1)
1694 backend = capture[0][IP].dst
1696 sessions = self.vapi.nat44_user_session_dump(backend, 0)
1697 self.assertEqual(len(sessions), 1)
1698 self.assertTrue(sessions[0].flags &
1699 self.config_flags.NAT_IS_EXT_HOST_VALID)
1700 self.vapi.nat44_del_session(
1701 address=sessions[0].inside_ip_address,
1702 port=sessions[0].inside_port,
1703 protocol=sessions[0].protocol,
1704 flags=(self.config_flags.NAT_IS_INSIDE |
1705 self.config_flags.NAT_IS_EXT_HOST_VALID),
1706 ext_host_address=sessions[0].ext_host_address,
1707 ext_host_port=sessions[0].ext_host_port)
1710 for port in range(1030, 1100):
1711 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1712 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1713 TCP(sport=port, dport=external_port))
1715 self.pg1.add_stream(pkts)
1716 self.pg_enable_capture(self.pg_interfaces)
1718 capture = self.pg0.get_capture(len(pkts))
1720 self.assertEqual(p[IP].dst, backend)
1722 def test_multiple_vrf_1(self):
1723 """ Multiple VRF - both client & service in VRF1 """
1725 external_addr = '1.2.3.4'
1730 flags = self.config_flags.NAT_IS_INSIDE
1731 self.vapi.nat44_interface_add_del_feature(
1732 sw_if_index=self.pg5.sw_if_index,
1734 self.vapi.nat44_interface_add_del_feature(
1735 sw_if_index=self.pg5.sw_if_index,
1736 is_add=1, flags=flags)
1737 self.vapi.nat44_interface_add_del_feature(
1738 sw_if_index=self.pg6.sw_if_index,
1740 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1741 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1742 local_port, external_port, vrf_id=1,
1743 proto=IP_PROTOS.tcp, flags=flags)
1745 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
1746 IP(src=self.pg6.remote_ip4, dst=external_addr) /
1747 TCP(sport=12345, dport=external_port))
1748 self.pg6.add_stream(p)
1749 self.pg_enable_capture(self.pg_interfaces)
1751 capture = self.pg5.get_capture(1)
1756 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1757 self.assertEqual(tcp.dport, local_port)
1758 self.assert_packet_checksums_valid(p)
1760 self.logger.error(ppp("Unexpected or invalid packet:", p))
1763 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1764 IP(src=self.pg5.remote_ip4, dst=self.pg6.remote_ip4) /
1765 TCP(sport=local_port, dport=12345))
1766 self.pg5.add_stream(p)
1767 self.pg_enable_capture(self.pg_interfaces)
1769 capture = self.pg6.get_capture(1)
1774 self.assertEqual(ip.src, external_addr)
1775 self.assertEqual(tcp.sport, external_port)
1776 self.assert_packet_checksums_valid(p)
1778 self.logger.error(ppp("Unexpected or invalid packet:", p))
1781 def test_multiple_vrf_2(self):
1782 """ Multiple VRF - dynamic NAT from VRF1 to VRF0 (output-feature) """
1784 external_addr = '1.2.3.4'
1789 self.nat_add_address(self.nat_addr)
1790 flags = self.config_flags.NAT_IS_INSIDE
1791 self.vapi.nat44_interface_add_del_output_feature(
1792 sw_if_index=self.pg1.sw_if_index,
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 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1806 IP(src=self.pg5.remote_ip4, dst=self.pg1.remote_ip4) /
1807 TCP(sport=2345, dport=22))
1808 self.pg5.add_stream(p)
1809 self.pg_enable_capture(self.pg_interfaces)
1811 capture = self.pg1.get_capture(1)
1816 self.assertEqual(ip.src, self.nat_addr)
1817 self.assert_packet_checksums_valid(p)
1820 self.logger.error(ppp("Unexpected or invalid packet:", p))
1823 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1824 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1825 TCP(sport=22, dport=port))
1826 self.pg1.add_stream(p)
1827 self.pg_enable_capture(self.pg_interfaces)
1829 capture = self.pg5.get_capture(1)
1834 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1835 self.assertEqual(tcp.dport, 2345)
1836 self.assert_packet_checksums_valid(p)
1838 self.logger.error(ppp("Unexpected or invalid packet:", p))
1841 def test_multiple_vrf_3(self):
1842 """ Multiple VRF - client in VRF1, service in VRF0 """
1844 external_addr = '1.2.3.4'
1849 flags = self.config_flags.NAT_IS_INSIDE
1850 self.vapi.nat44_interface_add_del_feature(
1851 sw_if_index=self.pg0.sw_if_index,
1853 self.vapi.nat44_interface_add_del_feature(
1854 sw_if_index=self.pg0.sw_if_index,
1855 is_add=1, flags=flags)
1856 self.vapi.nat44_interface_add_del_feature(
1857 sw_if_index=self.pg6.sw_if_index,
1859 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1860 self.nat_add_static_mapping(
1861 self.pg0.remote_ip4,
1862 external_sw_if_index=self.pg0.sw_if_index,
1863 local_port=local_port,
1865 external_port=external_port,
1866 proto=IP_PROTOS.tcp,
1870 # from client VRF1 to service VRF0
1871 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
1872 IP(src=self.pg6.remote_ip4, dst=self.pg0.local_ip4) /
1873 TCP(sport=12346, dport=external_port))
1874 self.pg6.add_stream(p)
1875 self.pg_enable_capture(self.pg_interfaces)
1877 capture = self.pg0.get_capture(1)
1882 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1883 self.assertEqual(tcp.dport, local_port)
1884 self.assert_packet_checksums_valid(p)
1886 self.logger.error(ppp("Unexpected or invalid packet:", p))
1889 # from service VRF0 back to client VRF1
1890 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1891 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
1892 TCP(sport=local_port, dport=12346))
1893 self.pg0.add_stream(p)
1894 self.pg_enable_capture(self.pg_interfaces)
1896 capture = self.pg6.get_capture(1)
1901 self.assertEqual(ip.src, self.pg0.local_ip4)
1902 self.assertEqual(tcp.sport, external_port)
1903 self.assert_packet_checksums_valid(p)
1905 self.logger.error(ppp("Unexpected or invalid packet:", p))
1908 def test_multiple_vrf_4(self):
1909 """ Multiple VRF - client in VRF0, service in VRF1 """
1911 external_addr = '1.2.3.4'
1916 flags = self.config_flags.NAT_IS_INSIDE
1917 self.vapi.nat44_interface_add_del_feature(
1918 sw_if_index=self.pg0.sw_if_index,
1920 self.vapi.nat44_interface_add_del_feature(
1921 sw_if_index=self.pg0.sw_if_index,
1922 is_add=1, flags=flags)
1923 self.vapi.nat44_interface_add_del_feature(
1924 sw_if_index=self.pg5.sw_if_index,
1926 self.vapi.nat44_interface_add_del_feature(
1927 sw_if_index=self.pg5.sw_if_index,
1928 is_add=1, flags=flags)
1929 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1930 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1931 local_port, external_port, vrf_id=1,
1932 proto=IP_PROTOS.tcp, flags=flags)
1934 # from client VRF0 to service VRF1
1935 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1936 IP(src=self.pg0.remote_ip4, dst=external_addr) /
1937 TCP(sport=12347, dport=external_port))
1938 self.pg0.add_stream(p)
1939 self.pg_enable_capture(self.pg_interfaces)
1941 capture = self.pg5.get_capture(1)
1946 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1947 self.assertEqual(tcp.dport, local_port)
1948 self.assert_packet_checksums_valid(p)
1950 self.logger.error(ppp("Unexpected or invalid packet:", p))
1953 # from service VRF1 back to client VRF0
1954 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1955 IP(src=self.pg5.remote_ip4, dst=self.pg0.remote_ip4) /
1956 TCP(sport=local_port, dport=12347))
1957 self.pg5.add_stream(p)
1958 self.pg_enable_capture(self.pg_interfaces)
1960 capture = self.pg0.get_capture(1)
1965 self.assertEqual(ip.src, external_addr)
1966 self.assertEqual(tcp.sport, external_port)
1967 self.assert_packet_checksums_valid(p)
1969 self.logger.error(ppp("Unexpected or invalid packet:", p))
1972 def test_multiple_vrf_5(self):
1973 """ Multiple VRF - forwarding - no translation """
1975 external_addr = '1.2.3.4'
1980 self.vapi.nat44_forwarding_enable_disable(enable=1)
1981 flags = self.config_flags.NAT_IS_INSIDE
1982 self.vapi.nat44_interface_add_del_feature(
1983 sw_if_index=self.pg0.sw_if_index,
1985 self.vapi.nat44_interface_add_del_feature(
1986 sw_if_index=self.pg0.sw_if_index,
1987 is_add=1, flags=flags)
1988 self.vapi.nat44_interface_add_del_feature(
1989 sw_if_index=self.pg5.sw_if_index,
1991 self.vapi.nat44_interface_add_del_feature(
1992 sw_if_index=self.pg5.sw_if_index,
1993 is_add=1, flags=flags)
1994 self.vapi.nat44_interface_add_del_feature(
1995 sw_if_index=self.pg6.sw_if_index,
1997 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1998 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1999 local_port, external_port, vrf_id=1,
2000 proto=IP_PROTOS.tcp, flags=flags)
2001 self.nat_add_static_mapping(
2002 self.pg0.remote_ip4,
2003 external_sw_if_index=self.pg0.sw_if_index,
2004 local_port=local_port,
2006 external_port=external_port,
2007 proto=IP_PROTOS.tcp,
2011 # from client to server (both VRF1, no translation)
2012 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
2013 IP(src=self.pg6.remote_ip4, dst=self.pg5.remote_ip4) /
2014 TCP(sport=12348, dport=local_port))
2015 self.pg6.add_stream(p)
2016 self.pg_enable_capture(self.pg_interfaces)
2018 capture = self.pg5.get_capture(1)
2023 self.assertEqual(ip.dst, self.pg5.remote_ip4)
2024 self.assertEqual(tcp.dport, local_port)
2025 self.assert_packet_checksums_valid(p)
2027 self.logger.error(ppp("Unexpected or invalid packet:", p))
2030 # from server back to client (both VRF1, no translation)
2031 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
2032 IP(src=self.pg5.remote_ip4, dst=self.pg6.remote_ip4) /
2033 TCP(sport=local_port, dport=12348))
2034 self.pg5.add_stream(p)
2035 self.pg_enable_capture(self.pg_interfaces)
2037 capture = self.pg6.get_capture(1)
2042 self.assertEqual(ip.src, self.pg5.remote_ip4)
2043 self.assertEqual(tcp.sport, local_port)
2044 self.assert_packet_checksums_valid(p)
2046 self.logger.error(ppp("Unexpected or invalid packet:", p))
2049 # from client VRF1 to server VRF0 (no translation)
2050 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2051 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
2052 TCP(sport=local_port, dport=12349))
2053 self.pg0.add_stream(p)
2054 self.pg_enable_capture(self.pg_interfaces)
2056 capture = self.pg6.get_capture(1)
2061 self.assertEqual(ip.src, self.pg0.remote_ip4)
2062 self.assertEqual(tcp.sport, local_port)
2063 self.assert_packet_checksums_valid(p)
2065 self.logger.error(ppp("Unexpected or invalid packet:", p))
2068 # from server VRF0 back to client VRF1 (no translation)
2069 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2070 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
2071 TCP(sport=local_port, dport=12349))
2072 self.pg0.add_stream(p)
2073 self.pg_enable_capture(self.pg_interfaces)
2075 capture = self.pg6.get_capture(1)
2080 self.assertEqual(ip.src, self.pg0.remote_ip4)
2081 self.assertEqual(tcp.sport, local_port)
2082 self.assert_packet_checksums_valid(p)
2084 self.logger.error(ppp("Unexpected or invalid packet:", p))
2087 # from client VRF0 to server VRF1 (no translation)
2088 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2089 IP(src=self.pg0.remote_ip4, dst=self.pg5.remote_ip4) /
2090 TCP(sport=12344, dport=local_port))
2091 self.pg0.add_stream(p)
2092 self.pg_enable_capture(self.pg_interfaces)
2094 capture = self.pg5.get_capture(1)
2099 self.assertEqual(ip.dst, self.pg5.remote_ip4)
2100 self.assertEqual(tcp.dport, local_port)
2101 self.assert_packet_checksums_valid(p)
2103 self.logger.error(ppp("Unexpected or invalid packet:", p))
2106 # from server VRF1 back to client VRF0 (no translation)
2107 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
2108 IP(src=self.pg5.remote_ip4, dst=self.pg0.remote_ip4) /
2109 TCP(sport=local_port, dport=12344))
2110 self.pg5.add_stream(p)
2111 self.pg_enable_capture(self.pg_interfaces)
2113 capture = self.pg0.get_capture(1)
2118 self.assertEqual(ip.src, self.pg5.remote_ip4)
2119 self.assertEqual(tcp.sport, local_port)
2120 self.assert_packet_checksums_valid(p)
2122 self.logger.error(ppp("Unexpected or invalid packet:", p))
2125 def test_outside_address_distribution(self):
2126 """ Outside address distribution based on source address """
2131 for i in range(1, x):
2133 nat_addresses.append(a)
2135 self.nat_add_inside_interface(self.pg0)
2136 self.nat_add_outside_interface(self.pg1)
2138 self.vapi.nat44_add_del_address_range(
2139 first_ip_address=nat_addresses[0],
2140 last_ip_address=nat_addresses[-1],
2141 vrf_id=0xFFFFFFFF, is_add=1, flags=0)
2143 self.pg0.generate_remote_hosts(x)
2147 info = self.create_packet_info(self.pg0, self.pg1)
2148 payload = self.info_to_payload(info)
2149 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2150 IP(src=self.pg0.remote_hosts[i].ip4,
2151 dst=self.pg1.remote_ip4) /
2152 UDP(sport=7000+i, dport=8000+i) /
2157 self.pg0.add_stream(pkts)
2158 self.pg_enable_capture(self.pg_interfaces)
2160 recvd = self.pg1.get_capture(len(pkts))
2161 for p_recvd in recvd:
2162 payload_info = self.payload_to_info(p_recvd[Raw])
2163 packet_index = payload_info.index
2164 info = self._packet_infos[packet_index]
2165 self.assertTrue(info is not None)
2166 self.assertEqual(packet_index, info.index)
2168 packed = socket.inet_aton(p_sent[IP].src)
2169 numeric = struct.unpack("!L", packed)[0]
2170 numeric = socket.htonl(numeric)
2171 a = nat_addresses[(numeric-1) % len(nat_addresses)]
2174 "Invalid packet (src IP %s translated to %s, but expected %s)"
2175 % (p_sent[IP].src, p_recvd[IP].src, a))
2178 class TestNAT44EDMW(TestNAT44ED):
2179 """ NAT44ED MW Test Case """
2180 vpp_worker_count = 4
2183 def test_dynamic(self):
2184 """ NAT44ED dynamic translation test """
2186 tcp_port_offset = 20
2187 udp_port_offset = 20
2190 self.nat_add_address(self.nat_addr)
2191 self.nat_add_inside_interface(self.pg0)
2192 self.nat_add_outside_interface(self.pg1)
2195 tc1 = self.statistics['/nat44-ed/in2out/slowpath/tcp']
2196 uc1 = self.statistics['/nat44-ed/in2out/slowpath/udp']
2197 ic1 = self.statistics['/nat44-ed/in2out/slowpath/icmp']
2198 dc1 = self.statistics['/nat44-ed/in2out/slowpath/drops']
2200 i2o_pkts = [[] for x in range(0, self.vpp_worker_count)]
2202 for i in range(pkt_count):
2203 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2204 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2205 TCP(sport=tcp_port_offset + i, dport=20))
2206 i2o_pkts[p[TCP].sport % self.vpp_worker_count].append(p)
2208 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2209 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2210 UDP(sport=udp_port_offset + i, dport=20))
2211 i2o_pkts[p[UDP].sport % self.vpp_worker_count].append(p)
2213 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2214 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2215 ICMP(id=icmp_id_offset + i, type='echo-request'))
2216 i2o_pkts[p[ICMP].id % self.vpp_worker_count].append(p)
2218 for i in range(0, self.vpp_worker_count):
2219 if len(i2o_pkts[i]) > 0:
2220 self.pg0.add_stream(i2o_pkts[i], worker=i)
2222 self.pg_enable_capture(self.pg_interfaces)
2224 capture = self.pg1.get_capture(pkt_count * 3, timeout=5)
2226 if_idx = self.pg0.sw_if_index
2227 tc2 = self.statistics['/nat44-ed/in2out/slowpath/tcp']
2228 uc2 = self.statistics['/nat44-ed/in2out/slowpath/udp']
2229 ic2 = self.statistics['/nat44-ed/in2out/slowpath/icmp']
2230 dc2 = self.statistics['/nat44-ed/in2out/slowpath/drops']
2233 tc2[:, if_idx].sum() - tc1[:, if_idx].sum(), pkt_count)
2235 uc2[:, if_idx].sum() - uc1[:, if_idx].sum(), pkt_count)
2237 ic2[:, if_idx].sum() - ic1[:, if_idx].sum(), pkt_count)
2238 self.assertEqual(dc2[:, if_idx].sum() - dc1[:, if_idx].sum(), 0)
2240 self.logger.info(self.vapi.cli("show trace"))
2243 tc1 = self.statistics['/nat44-ed/out2in/fastpath/tcp']
2244 uc1 = self.statistics['/nat44-ed/out2in/fastpath/udp']
2245 ic1 = self.statistics['/nat44-ed/out2in/fastpath/icmp']
2246 dc1 = self.statistics['/nat44-ed/out2in/fastpath/drops']
2248 recvd_tcp_ports = set()
2249 recvd_udp_ports = set()
2250 recvd_icmp_ids = set()
2254 recvd_tcp_ports.add(p[TCP].sport)
2256 recvd_udp_ports.add(p[UDP].sport)
2258 recvd_icmp_ids.add(p[ICMP].id)
2260 recvd_tcp_ports = list(recvd_tcp_ports)
2261 recvd_udp_ports = list(recvd_udp_ports)
2262 recvd_icmp_ids = list(recvd_icmp_ids)
2264 o2i_pkts = [[] for x in range(0, self.vpp_worker_count)]
2265 for i in range(pkt_count):
2266 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2267 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2268 TCP(dport=choice(recvd_tcp_ports), sport=20))
2269 o2i_pkts[p[TCP].dport % self.vpp_worker_count].append(p)
2271 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2272 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2273 UDP(dport=choice(recvd_udp_ports), sport=20))
2274 o2i_pkts[p[UDP].dport % self.vpp_worker_count].append(p)
2276 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2277 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2278 ICMP(id=choice(recvd_icmp_ids), type='echo-reply'))
2279 o2i_pkts[p[ICMP].id % self.vpp_worker_count].append(p)
2281 for i in range(0, self.vpp_worker_count):
2282 if len(o2i_pkts[i]) > 0:
2283 self.pg1.add_stream(o2i_pkts[i], worker=i)
2285 self.pg_enable_capture(self.pg_interfaces)
2287 capture = self.pg0.get_capture(pkt_count * 3)
2288 for packet in capture:
2290 self.assert_packet_checksums_valid(packet)
2291 self.assertEqual(packet[IP].dst, self.pg0.remote_ip4)
2292 if packet.haslayer(TCP):
2293 self.assert_in_range(
2294 packet[TCP].dport, tcp_port_offset,
2295 tcp_port_offset + pkt_count, "dst TCP port")
2296 elif packet.haslayer(UDP):
2297 self.assert_in_range(
2298 packet[UDP].dport, udp_port_offset,
2299 udp_port_offset + pkt_count, "dst UDP port")
2301 self.assert_in_range(
2302 packet[ICMP].id, icmp_id_offset,
2303 icmp_id_offset + pkt_count, "ICMP id")
2305 self.logger.error(ppp("Unexpected or invalid packet "
2306 "(inside network):", packet))
2309 if_idx = self.pg1.sw_if_index
2310 tc2 = self.statistics['/nat44-ed/out2in/fastpath/tcp']
2311 uc2 = self.statistics['/nat44-ed/out2in/fastpath/udp']
2312 ic2 = self.statistics['/nat44-ed/out2in/fastpath/icmp']
2313 dc2 = self.statistics['/nat44-ed/out2in/fastpath/drops']
2316 tc2[:, if_idx].sum() - tc1[:, if_idx].sum(), pkt_count)
2318 uc2[:, if_idx].sum() - uc1[:, if_idx].sum(), pkt_count)
2320 ic2[:, if_idx].sum() - ic1[:, if_idx].sum(), pkt_count)
2321 self.assertEqual(dc2[:, if_idx].sum() - dc1[:, if_idx].sum(), 0)
2323 sc = self.statistics['/nat44-ed/total-sessions']
2324 self.assertEqual(sc[:, 0].sum(), len(recvd_tcp_ports) +
2325 len(recvd_udp_ports) + len(recvd_icmp_ids))
2327 def test_frag_in_order(self):
2328 """ NAT44ED translate fragments arriving in order """
2330 self.nat_add_address(self.nat_addr)
2331 self.nat_add_inside_interface(self.pg0)
2332 self.nat_add_outside_interface(self.pg1)
2334 self.frag_in_order(proto=IP_PROTOS.tcp, ignore_port=True)
2335 self.frag_in_order(proto=IP_PROTOS.udp, ignore_port=True)
2336 self.frag_in_order(proto=IP_PROTOS.icmp, ignore_port=True)
2338 def test_frag_in_order_do_not_translate(self):
2339 """ NAT44ED don't translate fragments arriving in order """
2341 self.nat_add_address(self.nat_addr)
2342 self.nat_add_inside_interface(self.pg0)
2343 self.nat_add_outside_interface(self.pg1)
2344 self.vapi.nat44_forwarding_enable_disable(enable=True)
2346 self.frag_in_order(proto=IP_PROTOS.tcp, dont_translate=True)
2348 def test_frag_out_of_order(self):
2349 """ NAT44ED translate fragments arriving out of order """
2351 self.nat_add_address(self.nat_addr)
2352 self.nat_add_inside_interface(self.pg0)
2353 self.nat_add_outside_interface(self.pg1)
2355 self.frag_out_of_order(proto=IP_PROTOS.tcp, ignore_port=True)
2356 self.frag_out_of_order(proto=IP_PROTOS.udp, ignore_port=True)
2357 self.frag_out_of_order(proto=IP_PROTOS.icmp, ignore_port=True)
2359 def test_frag_in_order_in_plus_out(self):
2360 """ NAT44ED in+out interface fragments in order """
2362 in_port = self.random_port()
2363 out_port = self.random_port()
2365 self.nat_add_address(self.nat_addr)
2366 self.nat_add_inside_interface(self.pg0)
2367 self.nat_add_outside_interface(self.pg0)
2368 self.nat_add_inside_interface(self.pg1)
2369 self.nat_add_outside_interface(self.pg1)
2371 # add static mappings for server
2372 self.nat_add_static_mapping(self.server_addr,
2376 proto=IP_PROTOS.tcp)
2377 self.nat_add_static_mapping(self.server_addr,
2381 proto=IP_PROTOS.udp)
2382 self.nat_add_static_mapping(self.server_addr,
2384 proto=IP_PROTOS.icmp)
2386 # run tests for each protocol
2387 self.frag_in_order_in_plus_out(self.server_addr,
2392 self.frag_in_order_in_plus_out(self.server_addr,
2397 self.frag_in_order_in_plus_out(self.server_addr,
2403 def test_frag_out_of_order_in_plus_out(self):
2404 """ NAT44ED in+out interface fragments out of order """
2406 in_port = self.random_port()
2407 out_port = self.random_port()
2409 self.nat_add_address(self.nat_addr)
2410 self.nat_add_inside_interface(self.pg0)
2411 self.nat_add_outside_interface(self.pg0)
2412 self.nat_add_inside_interface(self.pg1)
2413 self.nat_add_outside_interface(self.pg1)
2415 # add static mappings for server
2416 self.nat_add_static_mapping(self.server_addr,
2420 proto=IP_PROTOS.tcp)
2421 self.nat_add_static_mapping(self.server_addr,
2425 proto=IP_PROTOS.udp)
2426 self.nat_add_static_mapping(self.server_addr,
2428 proto=IP_PROTOS.icmp)
2430 # run tests for each protocol
2431 self.frag_out_of_order_in_plus_out(self.server_addr,
2436 self.frag_out_of_order_in_plus_out(self.server_addr,
2441 self.frag_out_of_order_in_plus_out(self.server_addr,
2447 def test_reass_hairpinning(self):
2448 """ NAT44ED fragments hairpinning """
2450 server_addr = self.pg0.remote_hosts[1].ip4
2452 host_in_port = self.random_port()
2453 server_in_port = self.random_port()
2454 server_out_port = self.random_port()
2456 self.nat_add_address(self.nat_addr)
2457 self.nat_add_inside_interface(self.pg0)
2458 self.nat_add_outside_interface(self.pg1)
2460 # add static mapping for server
2461 self.nat_add_static_mapping(server_addr, self.nat_addr,
2462 server_in_port, server_out_port,
2463 proto=IP_PROTOS.tcp)
2464 self.nat_add_static_mapping(server_addr, self.nat_addr,
2465 server_in_port, server_out_port,
2466 proto=IP_PROTOS.udp)
2467 self.nat_add_static_mapping(server_addr, self.nat_addr)
2469 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2470 host_in_port, proto=IP_PROTOS.tcp,
2472 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2473 host_in_port, proto=IP_PROTOS.udp,
2475 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2476 host_in_port, proto=IP_PROTOS.icmp,
2479 def test_session_limit_per_vrf(self):
2480 """ NAT44ED per vrf session limit """
2483 inside_vrf10 = self.pg2
2488 # 2 interfaces pg0, pg1 (vrf10, limit 1 tcp session)
2489 # non existing vrf_id makes process core dump
2490 self.vapi.nat44_set_session_limit(session_limit=limit, vrf_id=10)
2492 self.nat_add_inside_interface(inside)
2493 self.nat_add_inside_interface(inside_vrf10)
2494 self.nat_add_outside_interface(outside)
2497 self.nat_add_interface_address(outside)
2499 # BUG: causing core dump - when bad vrf_id is specified
2500 # self.nat_add_address(outside.local_ip4, vrf_id=20)
2502 stream = self.create_tcp_stream(inside_vrf10, outside, limit * 2)
2503 inside_vrf10.add_stream(stream)
2505 self.pg_enable_capture(self.pg_interfaces)
2508 capture = outside.get_capture(limit)
2510 stream = self.create_tcp_stream(inside, outside, limit * 2)
2511 inside.add_stream(stream)
2513 self.pg_enable_capture(self.pg_interfaces)
2516 capture = outside.get_capture(len(stream))
2518 def test_show_max_translations(self):
2519 """ NAT44ED API test - max translations per thread """
2520 nat_config = self.vapi.nat_show_config_2()
2521 self.assertEqual(self.max_sessions,
2522 nat_config.max_translations_per_thread)
2524 def test_lru_cleanup(self):
2525 """ NAT44ED LRU cleanup algorithm """
2527 self.nat_add_address(self.nat_addr)
2528 self.nat_add_inside_interface(self.pg0)
2529 self.nat_add_outside_interface(self.pg1)
2531 self.vapi.nat_set_timeouts(
2532 udp=1, tcp_established=7440, tcp_transitory=30, icmp=1)
2534 tcp_port_out = self.init_tcp_session(self.pg0, self.pg1, 2000, 80)
2536 for i in range(0, self.max_sessions - 1):
2537 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2538 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4, ttl=64) /
2539 UDP(sport=7000+i, dport=80))
2542 self.pg0.add_stream(pkts)
2543 self.pg_enable_capture(self.pg_interfaces)
2545 self.pg1.get_capture(len(pkts))
2546 self.virtual_sleep(1.5, "wait for timeouts")
2549 for i in range(0, self.max_sessions - 1):
2550 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2551 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4, ttl=64) /
2552 ICMP(id=8000+i, type='echo-request'))
2555 self.pg0.add_stream(pkts)
2556 self.pg_enable_capture(self.pg_interfaces)
2558 self.pg1.get_capture(len(pkts))
2560 def test_session_rst_timeout(self):
2561 """ NAT44ED session RST timeouts """
2563 self.nat_add_address(self.nat_addr)
2564 self.nat_add_inside_interface(self.pg0)
2565 self.nat_add_outside_interface(self.pg1)
2567 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
2568 tcp_transitory=5, icmp=60)
2570 self.init_tcp_session(self.pg0, self.pg1, self.tcp_port_in,
2571 self.tcp_external_port)
2572 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2573 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2574 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port,
2576 self.send_and_expect(self.pg0, p, self.pg1)
2578 self.virtual_sleep(6)
2580 # The session is already closed
2581 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2582 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2583 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port,
2585 self.send_and_assert_no_replies(self.pg0, p, self.pg1)
2587 # The session can be re-opened
2588 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2589 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2590 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port,
2592 self.send_and_expect(self.pg0, p, self.pg1)
2594 def test_session_rst_established_timeout(self):
2595 """ NAT44ED session RST timeouts """
2597 self.nat_add_address(self.nat_addr)
2598 self.nat_add_inside_interface(self.pg0)
2599 self.nat_add_outside_interface(self.pg1)
2601 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
2602 tcp_transitory=5, icmp=60)
2604 self.init_tcp_session(self.pg0, self.pg1, self.tcp_port_in,
2605 self.tcp_external_port)
2607 # Wait at least the transitory time, the session is in established
2608 # state anyway. RST followed by a data packet should keep it
2610 self.virtual_sleep(6)
2611 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2612 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2613 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port,
2615 self.send_and_expect(self.pg0, p, self.pg1)
2617 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2618 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2619 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port,
2621 self.send_and_expect(self.pg0, p, self.pg1)
2623 # State is established, session should be still open after 6 seconds
2624 self.virtual_sleep(6)
2626 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2627 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2628 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port,
2630 self.send_and_expect(self.pg0, p, self.pg1)
2632 # State is transitory, session should be closed after 6 seconds
2633 self.virtual_sleep(6)
2635 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2636 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2637 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port,
2639 self.send_and_assert_no_replies(self.pg0, p, self.pg1)
2641 def test_dynamic_out_of_ports(self):
2642 """ NAT44ED dynamic translation test: out of ports """
2644 self.nat_add_inside_interface(self.pg0)
2645 self.nat_add_outside_interface(self.pg1)
2647 # in2out and no NAT addresses added
2648 pkts = self.create_stream_in(self.pg0, self.pg1)
2650 self.send_and_assert_no_replies(
2651 self.pg0, pkts, msg="i2o pkts",
2652 stats_diff=self.no_diff | {
2654 '/err/nat44-ed-in2out-slowpath/out of ports': len(pkts),
2656 self.pg0.sw_if_index: {
2657 '/nat44-ed/in2out/slowpath/drops': len(pkts),
2662 # in2out after NAT addresses added
2663 self.nat_add_address(self.nat_addr)
2665 tcpn, udpn, icmpn = (sum(x) for x in
2666 zip(*((TCP in p, UDP in p, ICMP in p)
2669 self.send_and_expect(
2670 self.pg0, pkts, self.pg1, msg="i2o pkts",
2671 stats_diff=self.no_diff | {
2673 '/err/nat44-ed-in2out-slowpath/out of ports': 0,
2675 self.pg0.sw_if_index: {
2676 '/nat44-ed/in2out/slowpath/drops': 0,
2677 '/nat44-ed/in2out/slowpath/tcp': tcpn,
2678 '/nat44-ed/in2out/slowpath/udp': udpn,
2679 '/nat44-ed/in2out/slowpath/icmp': icmpn,
2684 def test_unknown_proto(self):
2685 """ NAT44ED translate packet with unknown protocol """
2687 self.nat_add_address(self.nat_addr)
2688 self.nat_add_inside_interface(self.pg0)
2689 self.nat_add_outside_interface(self.pg1)
2692 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2693 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2694 TCP(sport=self.tcp_port_in, dport=20))
2695 self.pg0.add_stream(p)
2696 self.pg_enable_capture(self.pg_interfaces)
2698 p = self.pg1.get_capture(1)
2700 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2701 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2703 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2704 TCP(sport=1234, dport=1234))
2705 self.pg0.add_stream(p)
2706 self.pg_enable_capture(self.pg_interfaces)
2708 p = self.pg1.get_capture(1)
2711 self.assertEqual(packet[IP].src, self.nat_addr)
2712 self.assertEqual(packet[IP].dst, self.pg1.remote_ip4)
2713 self.assertEqual(packet.haslayer(GRE), 1)
2714 self.assert_packet_checksums_valid(packet)
2716 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2720 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2721 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2723 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2724 TCP(sport=1234, dport=1234))
2725 self.pg1.add_stream(p)
2726 self.pg_enable_capture(self.pg_interfaces)
2728 p = self.pg0.get_capture(1)
2731 self.assertEqual(packet[IP].src, self.pg1.remote_ip4)
2732 self.assertEqual(packet[IP].dst, self.pg0.remote_ip4)
2733 self.assertEqual(packet.haslayer(GRE), 1)
2734 self.assert_packet_checksums_valid(packet)
2736 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2739 def test_hairpinning_unknown_proto(self):
2740 """ NAT44ED translate packet with unknown protocol - hairpinning """
2741 host = self.pg0.remote_hosts[0]
2742 server = self.pg0.remote_hosts[1]
2744 server_out_port = 8765
2745 server_nat_ip = "10.0.0.11"
2747 self.nat_add_address(self.nat_addr)
2748 self.nat_add_inside_interface(self.pg0)
2749 self.nat_add_outside_interface(self.pg1)
2751 # add static mapping for server
2752 self.nat_add_static_mapping(server.ip4, server_nat_ip)
2755 p = (Ether(src=host.mac, dst=self.pg0.local_mac) /
2756 IP(src=host.ip4, dst=server_nat_ip) /
2757 TCP(sport=host_in_port, dport=server_out_port))
2758 self.pg0.add_stream(p)
2759 self.pg_enable_capture(self.pg_interfaces)
2761 self.pg0.get_capture(1)
2763 p = (Ether(dst=self.pg0.local_mac, src=host.mac) /
2764 IP(src=host.ip4, dst=server_nat_ip) /
2766 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2767 TCP(sport=1234, dport=1234))
2768 self.pg0.add_stream(p)
2769 self.pg_enable_capture(self.pg_interfaces)
2771 p = self.pg0.get_capture(1)
2774 self.assertEqual(packet[IP].src, self.nat_addr)
2775 self.assertEqual(packet[IP].dst, server.ip4)
2776 self.assertEqual(packet.haslayer(GRE), 1)
2777 self.assert_packet_checksums_valid(packet)
2779 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2783 p = (Ether(dst=self.pg0.local_mac, src=server.mac) /
2784 IP(src=server.ip4, dst=self.nat_addr) /
2786 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2787 TCP(sport=1234, dport=1234))
2788 self.pg0.add_stream(p)
2789 self.pg_enable_capture(self.pg_interfaces)
2791 p = self.pg0.get_capture(1)
2794 self.assertEqual(packet[IP].src, server_nat_ip)
2795 self.assertEqual(packet[IP].dst, host.ip4)
2796 self.assertEqual(packet.haslayer(GRE), 1)
2797 self.assert_packet_checksums_valid(packet)
2799 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2802 def test_output_feature_and_service(self):
2803 """ NAT44ED interface output feature and services """
2804 external_addr = '1.2.3.4'
2808 self.vapi.nat44_forwarding_enable_disable(enable=1)
2809 self.nat_add_address(self.nat_addr)
2810 flags = self.config_flags.NAT_IS_ADDR_ONLY
2811 self.vapi.nat44_add_del_identity_mapping(
2812 ip_address=self.pg1.remote_ip4, sw_if_index=0xFFFFFFFF,
2813 flags=flags, is_add=1)
2814 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
2815 self.nat_add_static_mapping(self.pg0.remote_ip4, external_addr,
2816 local_port, external_port,
2817 proto=IP_PROTOS.tcp, flags=flags)
2819 self.nat_add_inside_interface(self.pg0)
2820 self.nat_add_outside_interface(self.pg0)
2821 self.vapi.nat44_ed_add_del_output_interface(
2822 sw_if_index=self.pg1.sw_if_index, is_add=1)
2824 # from client to service
2825 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2826 IP(src=self.pg1.remote_ip4, dst=external_addr) /
2827 TCP(sport=12345, dport=external_port))
2828 self.pg1.add_stream(p)
2829 self.pg_enable_capture(self.pg_interfaces)
2831 capture = self.pg0.get_capture(1)
2836 self.assertEqual(ip.dst, self.pg0.remote_ip4)
2837 self.assertEqual(tcp.dport, local_port)
2838 self.assert_packet_checksums_valid(p)
2840 self.logger.error(ppp("Unexpected or invalid packet:", p))
2843 # from service back to client
2844 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2845 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2846 TCP(sport=local_port, dport=12345))
2847 self.pg0.add_stream(p)
2848 self.pg_enable_capture(self.pg_interfaces)
2850 capture = self.pg1.get_capture(1)
2855 self.assertEqual(ip.src, external_addr)
2856 self.assertEqual(tcp.sport, external_port)
2857 self.assert_packet_checksums_valid(p)
2859 self.logger.error(ppp("Unexpected or invalid packet:", p))
2862 # from local network host to external network
2863 pkts = self.create_stream_in(self.pg0, self.pg1)
2864 self.pg0.add_stream(pkts)
2865 self.pg_enable_capture(self.pg_interfaces)
2867 capture = self.pg1.get_capture(len(pkts))
2868 self.verify_capture_out(capture, ignore_port=True)
2869 pkts = self.create_stream_in(self.pg0, self.pg1)
2870 self.pg0.add_stream(pkts)
2871 self.pg_enable_capture(self.pg_interfaces)
2873 capture = self.pg1.get_capture(len(pkts))
2874 self.verify_capture_out(capture, ignore_port=True)
2876 # from external network back to local network host
2877 pkts = self.create_stream_out(self.pg1)
2878 self.pg1.add_stream(pkts)
2879 self.pg_enable_capture(self.pg_interfaces)
2881 capture = self.pg0.get_capture(len(pkts))
2882 self.verify_capture_in(capture, self.pg0)
2884 def test_output_feature_and_service3(self):
2885 """ NAT44ED interface output feature and DST NAT """
2886 external_addr = '1.2.3.4'
2890 self.vapi.nat44_forwarding_enable_disable(enable=1)
2891 self.nat_add_address(self.nat_addr)
2892 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
2893 self.nat_add_static_mapping(self.pg1.remote_ip4, external_addr,
2894 local_port, external_port,
2895 proto=IP_PROTOS.tcp, flags=flags)
2897 self.nat_add_inside_interface(self.pg0)
2898 self.nat_add_outside_interface(self.pg0)
2899 self.vapi.nat44_ed_add_del_output_interface(
2900 sw_if_index=self.pg1.sw_if_index, is_add=1)
2902 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2903 IP(src=self.pg0.remote_ip4, dst=external_addr) /
2904 TCP(sport=12345, dport=external_port))
2905 self.pg0.add_stream(p)
2906 self.pg_enable_capture(self.pg_interfaces)
2908 capture = self.pg1.get_capture(1)
2913 self.assertEqual(ip.src, self.pg0.remote_ip4)
2914 self.assertEqual(tcp.sport, 12345)
2915 self.assertEqual(ip.dst, self.pg1.remote_ip4)
2916 self.assertEqual(tcp.dport, local_port)
2917 self.assert_packet_checksums_valid(p)
2919 self.logger.error(ppp("Unexpected or invalid packet:", p))
2922 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2923 IP(src=self.pg1.remote_ip4, dst=self.pg0.remote_ip4) /
2924 TCP(sport=local_port, dport=12345))
2925 self.pg1.add_stream(p)
2926 self.pg_enable_capture(self.pg_interfaces)
2928 capture = self.pg0.get_capture(1)
2933 self.assertEqual(ip.src, external_addr)
2934 self.assertEqual(tcp.sport, external_port)
2935 self.assertEqual(ip.dst, self.pg0.remote_ip4)
2936 self.assertEqual(tcp.dport, 12345)
2937 self.assert_packet_checksums_valid(p)
2939 self.logger.error(ppp("Unexpected or invalid packet:", p))
2942 def test_self_twice_nat_lb_negative(self):
2943 """ NAT44ED Self Twice NAT local service load balancing (negative test)
2945 self.twice_nat_common(lb=True, self_twice_nat=True, same_pg=True,
2948 def test_self_twice_nat_negative(self):
2949 """ NAT44ED Self Twice NAT (negative test) """
2950 self.twice_nat_common(self_twice_nat=True)
2952 def test_static_lb_multi_clients(self):
2953 """ NAT44ED local service load balancing - multiple clients"""
2955 external_addr = self.nat_addr
2958 server1 = self.pg0.remote_hosts[0]
2959 server2 = self.pg0.remote_hosts[1]
2960 server3 = self.pg0.remote_hosts[2]
2962 locals = [{'addr': server1.ip4,
2966 {'addr': server2.ip4,
2971 flags = self.config_flags.NAT_IS_INSIDE
2972 self.vapi.nat44_interface_add_del_feature(
2973 sw_if_index=self.pg0.sw_if_index,
2974 flags=flags, is_add=1)
2975 self.vapi.nat44_interface_add_del_feature(
2976 sw_if_index=self.pg1.sw_if_index,
2979 self.nat_add_address(self.nat_addr)
2980 self.vapi.nat44_add_del_lb_static_mapping(is_add=1,
2981 external_addr=external_addr,
2982 external_port=external_port,
2983 protocol=IP_PROTOS.tcp,
2984 local_num=len(locals),
2989 clients = ip4_range(self.pg1.remote_ip4, 10, 50)
2991 for client in clients:
2992 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2993 IP(src=client, dst=self.nat_addr) /
2994 TCP(sport=12345, dport=external_port))
2996 self.pg1.add_stream(pkts)
2997 self.pg_enable_capture(self.pg_interfaces)
2999 capture = self.pg0.get_capture(len(pkts))
3001 if p[IP].dst == server1.ip4:
3005 self.assertGreaterEqual(server1_n, server2_n)
3008 'addr': server3.ip4,
3015 self.vapi.nat44_lb_static_mapping_add_del_local(
3017 external_addr=external_addr,
3018 external_port=external_port,
3020 protocol=IP_PROTOS.tcp)
3024 clients = ip4_range(self.pg1.remote_ip4, 60, 110)
3026 for client in clients:
3027 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3028 IP(src=client, dst=self.nat_addr) /
3029 TCP(sport=12346, dport=external_port))
3031 self.assertGreater(len(pkts), 0)
3032 self.pg1.add_stream(pkts)
3033 self.pg_enable_capture(self.pg_interfaces)
3035 capture = self.pg0.get_capture(len(pkts))
3037 if p[IP].dst == server1.ip4:
3039 elif p[IP].dst == server2.ip4:
3043 self.assertGreater(server1_n, 0)
3044 self.assertGreater(server2_n, 0)
3045 self.assertGreater(server3_n, 0)
3048 'addr': server2.ip4,
3054 # remove one back-end
3055 self.vapi.nat44_lb_static_mapping_add_del_local(
3057 external_addr=external_addr,
3058 external_port=external_port,
3060 protocol=IP_PROTOS.tcp)
3064 self.pg1.add_stream(pkts)
3065 self.pg_enable_capture(self.pg_interfaces)
3067 capture = self.pg0.get_capture(len(pkts))
3069 if p[IP].dst == server1.ip4:
3071 elif p[IP].dst == server2.ip4:
3075 self.assertGreater(server1_n, 0)
3076 self.assertEqual(server2_n, 0)
3077 self.assertGreater(server3_n, 0)
3079 # put zzz in front of syslog test name so that it runs as a last test
3080 # setting syslog sender cannot be undone and if it is set, it messes
3081 # with self.send_and_assert_no_replies functionality
3082 def test_zzz_syslog_sess(self):
3083 """ NAT44ED Test syslog session creation and deletion """
3084 self.vapi.syslog_set_filter(
3085 self.syslog_severity.SYSLOG_API_SEVERITY_INFO)
3086 self.vapi.syslog_set_sender(self.pg3.local_ip4, self.pg3.remote_ip4)
3088 self.nat_add_address(self.nat_addr)
3089 self.nat_add_inside_interface(self.pg0)
3090 self.nat_add_outside_interface(self.pg1)
3092 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
3093 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3094 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port))
3095 self.pg0.add_stream(p)
3096 self.pg_enable_capture(self.pg_interfaces)
3098 capture = self.pg1.get_capture(1)
3099 self.tcp_port_out = capture[0][TCP].sport
3100 capture = self.pg3.get_capture(1)
3101 self.verify_syslog_sess(capture[0][Raw].load, 'SADD')
3103 self.pg_enable_capture(self.pg_interfaces)
3105 self.nat_add_address(self.nat_addr, is_add=0)
3106 capture = self.pg3.get_capture(1)
3107 self.verify_syslog_sess(capture[0][Raw].load, 'SDEL')
3109 # put zzz in front of syslog test name so that it runs as a last test
3110 # setting syslog sender cannot be undone and if it is set, it messes
3111 # with self.send_and_assert_no_replies functionality
3112 def test_zzz_syslog_sess_reopen(self):
3113 """ Syslog events for session reopen """
3114 self.vapi.syslog_set_filter(
3115 self.syslog_severity.SYSLOG_API_SEVERITY_INFO)
3116 self.vapi.syslog_set_sender(self.pg3.local_ip4, self.pg3.remote_ip4)
3118 self.nat_add_address(self.nat_addr)
3119 self.nat_add_inside_interface(self.pg0)
3120 self.nat_add_outside_interface(self.pg1)
3123 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
3124 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3125 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port))
3126 capture = self.send_and_expect(self.pg0, p, self.pg1)[0]
3127 self.tcp_port_out = capture[0][TCP].sport
3128 capture = self.pg3.get_capture(1)
3129 self.verify_syslog_sess(capture[0][Raw].load, 'SADD')
3132 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
3133 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3134 TCP(sport=self.tcp_external_port, dport=self.tcp_port_out))
3135 self.send_and_expect(self.pg1, p, self.pg0)
3138 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
3139 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3140 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port,
3142 self.send_and_expect(self.pg0, p, self.pg1)
3145 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
3146 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3147 TCP(sport=self.tcp_external_port, dport=self.tcp_port_out,
3149 self.send_and_expect(self.pg1, p, self.pg0)
3152 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
3153 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3154 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port))
3155 self.send_and_expect(self.pg0, p, self.pg1)
3158 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
3159 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3160 TCP(sport=self.tcp_external_port, dport=self.tcp_port_out))
3161 self.send_and_expect(self.pg1, p, self.pg0)
3163 # 2 records should be produced - first one del & add
3164 capture = self.pg3.get_capture(2)
3165 self.verify_syslog_sess(capture[0][Raw].load, 'SDEL')
3166 self.verify_syslog_sess(capture[1][Raw].load, 'SADD')
3168 def test_twice_nat_interface_addr(self):
3169 """ NAT44ED Acquire twice NAT addresses from interface """
3170 flags = self.config_flags.NAT_IS_TWICE_NAT
3171 self.vapi.nat44_add_del_interface_addr(
3172 sw_if_index=self.pg11.sw_if_index,
3173 flags=flags, is_add=1)
3175 # no address in NAT pool
3176 adresses = self.vapi.nat44_address_dump()
3177 self.assertEqual(0, len(adresses))
3179 # configure interface address and check NAT address pool
3180 self.pg11.config_ip4()
3181 adresses = self.vapi.nat44_address_dump()
3182 self.assertEqual(1, len(adresses))
3183 self.assertEqual(str(adresses[0].ip_address),
3184 self.pg11.local_ip4)
3185 self.assertEqual(adresses[0].flags, flags)
3187 # remove interface address and check NAT address pool
3188 self.pg11.unconfig_ip4()
3189 adresses = self.vapi.nat44_address_dump()
3190 self.assertEqual(0, len(adresses))
3192 def test_output_feature_stateful_acl(self):
3193 """ NAT44ED output feature works with stateful ACL """
3195 self.nat_add_address(self.nat_addr)
3196 self.vapi.nat44_ed_add_del_output_interface(
3197 sw_if_index=self.pg1.sw_if_index, is_add=1)
3199 # First ensure that the NAT is working sans ACL
3201 # send packets out2in, no sessions yet so packets should drop
3202 pkts_out2in = self.create_stream_out(self.pg1)
3203 self.send_and_assert_no_replies(self.pg1, pkts_out2in)
3205 # send packets into inside intf, ensure received via outside intf
3206 pkts_in2out = self.create_stream_in(self.pg0, self.pg1)
3207 capture = self.send_and_expect(self.pg0, pkts_in2out, self.pg1,
3209 self.verify_capture_out(capture, ignore_port=True)
3211 # send out2in again, with sessions created it should work now
3212 pkts_out2in = self.create_stream_out(self.pg1)
3213 capture = self.send_and_expect(self.pg1, pkts_out2in, self.pg0,
3215 self.verify_capture_in(capture, self.pg0)
3217 # Create an ACL blocking everything
3218 out2in_deny_rule = AclRule(is_permit=0)
3219 out2in_acl = VppAcl(self, rules=[out2in_deny_rule])
3220 out2in_acl.add_vpp_config()
3222 # create an ACL to permit/reflect everything
3223 in2out_reflect_rule = AclRule(is_permit=2)
3224 in2out_acl = VppAcl(self, rules=[in2out_reflect_rule])
3225 in2out_acl.add_vpp_config()
3227 # apply as input acl on interface and confirm it blocks everything
3228 acl_if = VppAclInterface(self, sw_if_index=self.pg1.sw_if_index,
3229 n_input=1, acls=[out2in_acl])
3230 acl_if.add_vpp_config()
3231 self.send_and_assert_no_replies(self.pg1, pkts_out2in)
3234 acl_if.acls = [out2in_acl, in2out_acl]
3235 acl_if.add_vpp_config()
3236 # send in2out to generate ACL state (NAT state was created earlier)
3237 capture = self.send_and_expect(self.pg0, pkts_in2out, self.pg1,
3239 self.verify_capture_out(capture, ignore_port=True)
3241 # send out2in again. ACL state exists so it should work now.
3242 # TCP packets with the syn flag set also need the ack flag
3243 for p in pkts_out2in:
3244 if p.haslayer(TCP) and p[TCP].flags & 0x02:
3245 p[TCP].flags |= 0x10
3246 capture = self.send_and_expect(self.pg1, pkts_out2in, self.pg0,
3248 self.verify_capture_in(capture, self.pg0)
3249 self.logger.info(self.vapi.cli("show trace"))
3251 def test_tcp_close(self):
3252 """ NAT44ED Close TCP session from inside network - output feature """
3253 old_timeouts = self.vapi.nat_get_timeouts()
3255 self.vapi.nat_set_timeouts(
3256 udp=old_timeouts.udp,
3257 tcp_established=old_timeouts.tcp_established,
3258 icmp=old_timeouts.icmp,
3259 tcp_transitory=new_transitory)
3261 self.vapi.nat44_forwarding_enable_disable(enable=1)
3262 self.nat_add_address(self.pg1.local_ip4)
3263 twice_nat_addr = '10.0.1.3'
3264 service_ip = '192.168.16.150'
3265 self.nat_add_address(twice_nat_addr, twice_nat=1)
3267 flags = self.config_flags.NAT_IS_INSIDE
3268 self.vapi.nat44_interface_add_del_feature(
3269 sw_if_index=self.pg0.sw_if_index,
3271 self.vapi.nat44_interface_add_del_feature(
3272 sw_if_index=self.pg0.sw_if_index,
3273 flags=flags, is_add=1)
3274 self.vapi.nat44_ed_add_del_output_interface(
3276 sw_if_index=self.pg1.sw_if_index)
3278 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3279 self.config_flags.NAT_IS_TWICE_NAT)
3280 self.nat_add_static_mapping(self.pg0.remote_ip4,
3282 proto=IP_PROTOS.tcp,
3284 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3285 start_sessnum = len(sessions)
3287 # SYN packet out->in
3288 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3289 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3290 TCP(sport=33898, dport=80, flags="S"))
3291 capture = self.send_and_expect(self.pg1, p, self.pg0, n_rx=1)
3293 tcp_port = p[TCP].sport
3295 # SYN + ACK packet in->out
3296 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3297 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3298 TCP(sport=80, dport=tcp_port, flags="SA"))
3299 self.send_and_expect(self.pg0, p, self.pg1, n_rx=1)
3301 # ACK packet out->in
3302 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3303 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3304 TCP(sport=33898, dport=80, flags="A"))
3305 self.send_and_expect(self.pg1, p, self.pg0, n_rx=1)
3307 # FIN packet in -> out
3308 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3309 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3310 TCP(sport=80, dport=tcp_port, flags="FA", seq=100, ack=300))
3311 self.send_and_expect(self.pg0, p, self.pg1, n_rx=1)
3313 # FIN+ACK packet out -> in
3314 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3315 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3316 TCP(sport=33898, dport=80, flags="FA", seq=300, ack=101))
3317 self.send_and_expect(self.pg1, p, self.pg0, n_rx=1)
3319 # ACK packet in -> out
3320 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3321 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3322 TCP(sport=80, dport=tcp_port, flags="A", seq=101, ack=301))
3323 self.send_and_expect(self.pg0, p, self.pg1, n_rx=1)
3325 # session now in transitory timeout, but traffic still flows
3326 # try FIN packet out->in
3327 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3328 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3329 TCP(sport=33898, dport=80, flags="F"))
3330 self.pg1.add_stream(p)
3331 self.pg_enable_capture(self.pg_interfaces)
3334 self.virtual_sleep(new_transitory, "wait for transitory timeout")
3335 self.pg0.get_capture(1)
3337 # session should still exist
3338 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3339 self.assertEqual(len(sessions) - start_sessnum, 1)
3341 # send FIN+ACK packet out -> in - will cause session to be wiped
3342 # but won't create a new session
3343 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3344 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3345 TCP(sport=33898, dport=80, flags="FA", seq=300, ack=101))
3346 self.send_and_assert_no_replies(self.pg1, p)
3347 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3348 self.assertEqual(len(sessions) - start_sessnum, 0)
3350 def test_tcp_session_close_in(self):
3351 """ NAT44ED Close TCP session from inside network """
3353 in_port = self.tcp_port_in
3355 ext_port = self.tcp_external_port
3357 self.nat_add_address(self.nat_addr)
3358 self.nat_add_inside_interface(self.pg0)
3359 self.nat_add_outside_interface(self.pg1)
3360 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3361 in_port, out_port, proto=IP_PROTOS.tcp,
3362 flags=self.config_flags.NAT_IS_TWICE_NAT)
3364 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3365 session_n = len(sessions)
3367 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3368 tcp_transitory=2, icmp=5)
3370 self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3372 # FIN packet in -> out
3373 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3374 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3375 TCP(sport=in_port, dport=ext_port,
3376 flags="FA", seq=100, ack=300))
3377 self.send_and_expect(self.pg0, p, self.pg1)
3380 # ACK packet out -> in
3381 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3382 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3383 TCP(sport=ext_port, dport=out_port,
3384 flags="A", seq=300, ack=101))
3387 # FIN packet out -> in
3388 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3389 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3390 TCP(sport=ext_port, dport=out_port,
3391 flags="FA", seq=300, ack=101))
3394 self.send_and_expect(self.pg1, pkts, self.pg0)
3396 # ACK packet in -> out
3397 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3398 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3399 TCP(sport=in_port, dport=ext_port,
3400 flags="A", seq=101, ack=301))
3401 self.send_and_expect(self.pg0, p, self.pg1)
3403 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3404 self.assertEqual(len(sessions) - session_n, 1)
3406 # retransmit FIN packet out -> in
3407 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3408 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3409 TCP(sport=ext_port, dport=out_port,
3410 flags="FA", seq=300, ack=101))
3412 self.send_and_expect(self.pg1, p, self.pg0)
3414 # retransmit ACK packet in -> out
3415 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3416 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3417 TCP(sport=in_port, dport=ext_port,
3418 flags="A", seq=101, ack=301))
3419 self.send_and_expect(self.pg0, p, self.pg1)
3421 self.virtual_sleep(3)
3422 # retransmit ACK packet in -> out - this will cause session to be wiped
3423 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3424 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3425 TCP(sport=in_port, dport=ext_port,
3426 flags="A", seq=101, ack=301))
3427 self.send_and_assert_no_replies(self.pg0, p)
3428 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3429 self.assertEqual(len(sessions) - session_n, 0)
3431 def test_tcp_session_close_out(self):
3432 """ NAT44ED Close TCP session from outside network """
3434 in_port = self.tcp_port_in
3436 ext_port = self.tcp_external_port
3438 self.nat_add_address(self.nat_addr)
3439 self.nat_add_inside_interface(self.pg0)
3440 self.nat_add_outside_interface(self.pg1)
3441 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3442 in_port, out_port, proto=IP_PROTOS.tcp,
3443 flags=self.config_flags.NAT_IS_TWICE_NAT)
3445 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3446 session_n = len(sessions)
3448 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3449 tcp_transitory=2, icmp=5)
3451 _ = self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3453 # FIN packet out -> in
3454 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3455 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3456 TCP(sport=ext_port, dport=out_port,
3457 flags="FA", seq=100, ack=300))
3458 self.pg1.add_stream(p)
3459 self.pg_enable_capture(self.pg_interfaces)
3461 self.pg0.get_capture(1)
3463 # FIN+ACK packet in -> out
3464 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3465 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3466 TCP(sport=in_port, dport=ext_port,
3467 flags="FA", seq=300, ack=101))
3469 self.pg0.add_stream(p)
3470 self.pg_enable_capture(self.pg_interfaces)
3472 self.pg1.get_capture(1)
3474 # ACK packet out -> in
3475 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3476 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3477 TCP(sport=ext_port, dport=out_port,
3478 flags="A", seq=101, ack=301))
3479 self.pg1.add_stream(p)
3480 self.pg_enable_capture(self.pg_interfaces)
3482 self.pg0.get_capture(1)
3484 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3485 self.assertEqual(len(sessions) - session_n, 1)
3487 # retransmit FIN packet out -> in
3488 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3489 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3490 TCP(sport=ext_port, dport=out_port,
3491 flags="FA", seq=300, ack=101))
3492 self.send_and_expect(self.pg1, p, self.pg0)
3494 # retransmit ACK packet in -> out
3495 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3496 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3497 TCP(sport=in_port, dport=ext_port,
3498 flags="A", seq=101, ack=301))
3499 self.send_and_expect(self.pg0, p, self.pg1)
3501 self.virtual_sleep(3)
3502 # retransmit ACK packet in -> out - this will cause session to be wiped
3503 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3504 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3505 TCP(sport=in_port, dport=ext_port,
3506 flags="A", seq=101, ack=301))
3507 self.send_and_assert_no_replies(self.pg0, p)
3508 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3509 self.assertEqual(len(sessions) - session_n, 0)
3511 def test_tcp_session_close_simultaneous(self):
3512 """ Simultaneous TCP close from both sides """
3514 in_port = self.tcp_port_in
3517 self.nat_add_address(self.nat_addr)
3518 self.nat_add_inside_interface(self.pg0)
3519 self.nat_add_outside_interface(self.pg1)
3520 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3521 in_port, ext_port, proto=IP_PROTOS.tcp,
3522 flags=self.config_flags.NAT_IS_TWICE_NAT)
3524 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3525 session_n = len(sessions)
3527 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3528 tcp_transitory=2, icmp=5)
3530 out_port = self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3532 # FIN packet in -> out
3533 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3534 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3535 TCP(sport=in_port, dport=ext_port,
3536 flags="FA", seq=100, ack=300))
3537 self.send_and_expect(self.pg0, p, self.pg1)
3539 # FIN packet out -> in
3540 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3541 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3542 TCP(sport=ext_port, dport=out_port,
3543 flags="FA", seq=300, ack=100))
3544 self.send_and_expect(self.pg1, p, self.pg0)
3546 # ACK packet in -> out
3547 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3548 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3549 TCP(sport=in_port, dport=ext_port,
3550 flags="A", seq=101, ack=301))
3551 self.send_and_expect(self.pg0, p, self.pg1)
3553 # ACK packet out -> in
3554 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3555 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3556 TCP(sport=ext_port, dport=out_port,
3557 flags="A", seq=301, ack=101))
3558 self.send_and_expect(self.pg1, p, self.pg0)
3560 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3561 self.assertEqual(len(sessions) - session_n, 1)
3563 # retransmit FIN packet out -> in
3564 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3565 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3566 TCP(sport=ext_port, dport=out_port,
3567 flags="FA", seq=300, ack=101))
3568 self.send_and_expect(self.pg1, p, self.pg0)
3570 # retransmit ACK packet in -> out
3571 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3572 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3573 TCP(sport=in_port, dport=ext_port,
3574 flags="A", seq=101, ack=301))
3575 self.send_and_expect(self.pg0, p, self.pg1)
3577 self.virtual_sleep(3)
3578 # retransmit ACK packet in -> out - this will cause session to be wiped
3579 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3580 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3581 TCP(sport=in_port, dport=ext_port,
3582 flags="A", seq=101, ack=301))
3583 self.pg_send(self.pg0, p)
3584 self.send_and_assert_no_replies(self.pg0, p)
3585 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3586 self.assertEqual(len(sessions) - session_n, 0)
3588 def test_tcp_session_half_reopen_inside(self):
3589 """ TCP session in FIN/FIN state not reopened by in2out SYN only """
3590 in_port = self.tcp_port_in
3593 self.nat_add_address(self.nat_addr)
3594 self.nat_add_inside_interface(self.pg0)
3595 self.nat_add_outside_interface(self.pg1)
3596 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3597 in_port, ext_port, proto=IP_PROTOS.tcp,
3598 flags=self.config_flags.NAT_IS_TWICE_NAT)
3600 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3601 session_n = len(sessions)
3603 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3604 tcp_transitory=2, icmp=5)
3606 out_port = self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3608 # FIN packet in -> out
3609 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3610 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3611 TCP(sport=in_port, dport=ext_port,
3612 flags="FA", seq=100, ack=300))
3613 self.send_and_expect(self.pg0, p, self.pg1)
3615 # FIN packet out -> in
3616 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3617 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3618 TCP(sport=ext_port, dport=out_port,
3619 flags="FA", seq=300, ack=100))
3620 self.send_and_expect(self.pg1, p, self.pg0)
3622 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3623 self.assertEqual(len(sessions) - session_n, 1)
3625 # send SYN packet in -> out
3626 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3627 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3628 TCP(sport=in_port, dport=ext_port,
3629 flags="S", seq=101, ack=301))
3630 self.send_and_expect(self.pg0, p, self.pg1)
3632 self.virtual_sleep(3)
3633 # send ACK packet in -> out - session should be wiped
3634 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3635 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3636 TCP(sport=in_port, dport=ext_port,
3637 flags="A", seq=101, ack=301))
3638 self.send_and_assert_no_replies(self.pg0, p, self.pg1)
3639 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3640 self.assertEqual(len(sessions) - session_n, 0)
3642 def test_tcp_session_half_reopen_outside(self):
3643 """ TCP session in FIN/FIN state not reopened by out2in SYN only """
3644 in_port = self.tcp_port_in
3647 self.nat_add_address(self.nat_addr)
3648 self.nat_add_inside_interface(self.pg0)
3649 self.nat_add_outside_interface(self.pg1)
3650 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3651 in_port, ext_port, proto=IP_PROTOS.tcp,
3652 flags=self.config_flags.NAT_IS_TWICE_NAT)
3654 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3655 session_n = len(sessions)
3657 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3658 tcp_transitory=2, icmp=5)
3660 out_port = self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3662 # FIN packet in -> out
3663 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3664 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3665 TCP(sport=in_port, dport=ext_port,
3666 flags="FA", seq=100, ack=300))
3667 self.send_and_expect(self.pg0, p, self.pg1)
3669 # FIN packet out -> in
3670 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3671 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3672 TCP(sport=ext_port, dport=out_port,
3673 flags="FA", seq=300, ack=100))
3674 self.send_and_expect(self.pg1, p, self.pg0)
3676 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3677 self.assertEqual(len(sessions) - session_n, 1)
3679 # send SYN packet out -> in
3680 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3681 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3682 TCP(sport=ext_port, dport=out_port,
3683 flags="S", seq=300, ack=101))
3684 self.send_and_expect(self.pg1, p, self.pg0)
3686 self.virtual_sleep(3)
3687 # send ACK packet in -> out - session should be wiped
3688 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3689 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3690 TCP(sport=in_port, dport=ext_port,
3691 flags="A", seq=101, ack=301))
3692 self.send_and_assert_no_replies(self.pg0, p, self.pg1)
3693 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3694 self.assertEqual(len(sessions) - session_n, 0)
3696 def test_tcp_session_reopen(self):
3697 """ TCP session in FIN/FIN state reopened by SYN from both sides """
3698 in_port = self.tcp_port_in
3701 self.nat_add_address(self.nat_addr)
3702 self.nat_add_inside_interface(self.pg0)
3703 self.nat_add_outside_interface(self.pg1)
3704 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3705 in_port, ext_port, proto=IP_PROTOS.tcp,
3706 flags=self.config_flags.NAT_IS_TWICE_NAT)
3708 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3709 session_n = len(sessions)
3711 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3712 tcp_transitory=2, icmp=5)
3714 out_port = self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3716 # FIN packet in -> out
3717 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3718 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3719 TCP(sport=in_port, dport=ext_port,
3720 flags="FA", seq=100, ack=300))
3721 self.send_and_expect(self.pg0, p, self.pg1)
3723 # FIN packet out -> in
3724 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3725 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3726 TCP(sport=ext_port, dport=out_port,
3727 flags="FA", seq=300, ack=100))
3728 self.send_and_expect(self.pg1, p, self.pg0)
3730 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3731 self.assertEqual(len(sessions) - session_n, 1)
3733 # send SYN packet out -> in
3734 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3735 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3736 TCP(sport=ext_port, dport=out_port,
3737 flags="S", seq=300, ack=101))
3738 self.send_and_expect(self.pg1, p, self.pg0)
3740 # send SYN packet in -> out
3741 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3742 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3743 TCP(sport=in_port, dport=ext_port,
3744 flags="S", seq=101, ack=301))
3745 self.send_and_expect(self.pg0, p, self.pg1)
3747 self.virtual_sleep(3)
3748 # send ACK packet in -> out - should be forwarded and session alive
3749 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3750 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3751 TCP(sport=in_port, dport=ext_port,
3752 flags="A", seq=101, ack=301))
3753 self.send_and_expect(self.pg0, p, self.pg1)
3754 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3755 self.assertEqual(len(sessions) - session_n, 1)
3757 def test_dynamic_vrf(self):
3758 """ NAT44ED dynamic translation test: different VRF"""
3763 self.nat_add_address(self.nat_addr, vrf_id=vrf_id_in)
3766 self.configure_ip4_interface(self.pg7, table_id=vrf_id_in)
3767 self.configure_ip4_interface(self.pg8, table_id=vrf_id_out)
3769 self.nat_add_inside_interface(self.pg7)
3770 self.nat_add_outside_interface(self.pg8)
3772 # just basic stuff nothing special
3773 pkts = self.create_stream_in(self.pg7, self.pg8)
3774 self.pg7.add_stream(pkts)
3775 self.pg_enable_capture(self.pg_interfaces)
3777 capture = self.pg8.get_capture(len(pkts))
3778 self.verify_capture_out(capture, ignore_port=True)
3780 pkts = self.create_stream_out(self.pg8)
3781 self.pg8.add_stream(pkts)
3782 self.pg_enable_capture(self.pg_interfaces)
3784 capture = self.pg7.get_capture(len(pkts))
3785 self.verify_capture_in(capture, self.pg7)
3791 self.vapi.ip_table_add_del(is_add=0,
3792 table={'table_id': vrf_id_in})
3793 self.vapi.ip_table_add_del(is_add=0,
3794 table={'table_id': vrf_id_out})
3796 def test_dynamic_output_feature_vrf(self):
3797 """ NAT44ED dynamic translation test: output-feature, VRF"""
3799 # other then default (0)
3802 self.nat_add_address(self.nat_addr)
3803 self.vapi.nat44_interface_add_del_output_feature(
3804 sw_if_index=self.pg8.sw_if_index, is_add=1)
3807 self.configure_ip4_interface(self.pg7, table_id=new_vrf_id)
3808 self.configure_ip4_interface(self.pg8, table_id=new_vrf_id)
3811 tcpn = self.statistics['/nat44-ed/in2out/slowpath/tcp']
3812 udpn = self.statistics['/nat44-ed/in2out/slowpath/udp']
3813 icmpn = self.statistics['/nat44-ed/in2out/slowpath/icmp']
3814 drops = self.statistics['/nat44-ed/in2out/slowpath/drops']
3816 pkts = self.create_stream_in(self.pg7, self.pg8)
3817 self.pg7.add_stream(pkts)
3818 self.pg_enable_capture(self.pg_interfaces)
3820 capture = self.pg8.get_capture(len(pkts))
3821 self.verify_capture_out(capture, ignore_port=True)
3823 if_idx = self.pg8.sw_if_index
3824 cnt = self.statistics['/nat44-ed/in2out/slowpath/tcp']
3825 self.assertEqual(cnt[:, if_idx].sum() - tcpn[:, if_idx].sum(), 2)
3826 cnt = self.statistics['/nat44-ed/in2out/slowpath/udp']
3827 self.assertEqual(cnt[:, if_idx].sum() - udpn[:, if_idx].sum(), 1)
3828 cnt = self.statistics['/nat44-ed/in2out/slowpath/icmp']
3829 self.assertEqual(cnt[:, if_idx].sum() - icmpn[:, if_idx].sum(), 1)
3830 cnt = self.statistics['/nat44-ed/in2out/slowpath/drops']
3831 self.assertEqual(cnt[:, if_idx].sum() - drops[:, if_idx].sum(), 0)
3834 tcpn = self.statistics['/nat44-ed/out2in/fastpath/tcp']
3835 udpn = self.statistics['/nat44-ed/out2in/fastpath/udp']
3836 icmpn = self.statistics['/nat44-ed/out2in/fastpath/icmp']
3837 drops = self.statistics['/nat44-ed/out2in/fastpath/drops']
3839 pkts = self.create_stream_out(self.pg8)
3840 self.pg8.add_stream(pkts)
3841 self.pg_enable_capture(self.pg_interfaces)
3843 capture = self.pg7.get_capture(len(pkts))
3844 self.verify_capture_in(capture, self.pg7)
3846 if_idx = self.pg8.sw_if_index
3847 cnt = self.statistics['/nat44-ed/out2in/fastpath/tcp']
3848 self.assertEqual(cnt[:, if_idx].sum() - tcpn[:, if_idx].sum(), 2)
3849 cnt = self.statistics['/nat44-ed/out2in/fastpath/udp']
3850 self.assertEqual(cnt[:, if_idx].sum() - udpn[:, if_idx].sum(), 1)
3851 cnt = self.statistics['/nat44-ed/out2in/fastpath/icmp']
3852 self.assertEqual(cnt[:, if_idx].sum() - icmpn[:, if_idx].sum(), 1)
3853 cnt = self.statistics['/nat44-ed/out2in/fastpath/drops']
3854 self.assertEqual(cnt[:, if_idx].sum() - drops[:, if_idx].sum(), 0)
3856 sessions = self.statistics['/nat44-ed/total-sessions']
3857 self.assertEqual(sessions[:, 0].sum(), 3)
3863 self.vapi.ip_table_add_del(is_add=0,
3864 table={'table_id': new_vrf_id})
3866 def test_next_src_nat(self):
3867 """ NAT44ED On way back forward packet to nat44-in2out node. """
3869 twice_nat_addr = '10.0.1.3'
3872 post_twice_nat_port = 0
3874 self.vapi.nat44_forwarding_enable_disable(enable=1)
3875 self.nat_add_address(twice_nat_addr, twice_nat=1)
3876 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3877 self.config_flags.NAT_IS_SELF_TWICE_NAT)
3878 self.nat_add_static_mapping(self.pg6.remote_ip4, self.pg1.remote_ip4,
3879 local_port, external_port,
3880 proto=IP_PROTOS.tcp, vrf_id=1,
3882 self.vapi.nat44_interface_add_del_feature(
3883 sw_if_index=self.pg6.sw_if_index,
3886 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
3887 IP(src=self.pg6.remote_ip4, dst=self.pg1.remote_ip4) /
3888 TCP(sport=12345, dport=external_port))
3889 self.pg6.add_stream(p)
3890 self.pg_enable_capture(self.pg_interfaces)
3892 capture = self.pg6.get_capture(1)
3897 self.assertEqual(ip.src, twice_nat_addr)
3898 self.assertNotEqual(tcp.sport, 12345)
3899 post_twice_nat_port = tcp.sport
3900 self.assertEqual(ip.dst, self.pg6.remote_ip4)
3901 self.assertEqual(tcp.dport, local_port)
3902 self.assert_packet_checksums_valid(p)
3904 self.logger.error(ppp("Unexpected or invalid packet:", p))
3907 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
3908 IP(src=self.pg6.remote_ip4, dst=twice_nat_addr) /
3909 TCP(sport=local_port, dport=post_twice_nat_port))
3910 self.pg6.add_stream(p)
3911 self.pg_enable_capture(self.pg_interfaces)
3913 capture = self.pg6.get_capture(1)
3918 self.assertEqual(ip.src, self.pg1.remote_ip4)
3919 self.assertEqual(tcp.sport, external_port)
3920 self.assertEqual(ip.dst, self.pg6.remote_ip4)
3921 self.assertEqual(tcp.dport, 12345)
3922 self.assert_packet_checksums_valid(p)
3924 self.logger.error(ppp("Unexpected or invalid packet:", p))
3927 def test_one_armed_nat44_static(self):
3928 """ NAT44ED One armed NAT and 1:1 NAPT asymmetrical rule """
3930 remote_host = self.pg4.remote_hosts[0]
3931 local_host = self.pg4.remote_hosts[1]
3936 self.vapi.nat44_forwarding_enable_disable(enable=1)
3937 self.nat_add_address(self.nat_addr, twice_nat=1)
3938 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3939 self.config_flags.NAT_IS_TWICE_NAT)
3940 self.nat_add_static_mapping(local_host.ip4, self.nat_addr,
3941 local_port, external_port,
3942 proto=IP_PROTOS.tcp, flags=flags)
3943 flags = self.config_flags.NAT_IS_INSIDE
3944 self.vapi.nat44_interface_add_del_feature(
3945 sw_if_index=self.pg4.sw_if_index,
3947 self.vapi.nat44_interface_add_del_feature(
3948 sw_if_index=self.pg4.sw_if_index,
3949 flags=flags, is_add=1)
3951 # from client to service
3952 p = (Ether(src=self.pg4.remote_mac, dst=self.pg4.local_mac) /
3953 IP(src=remote_host.ip4, dst=self.nat_addr) /
3954 TCP(sport=12345, dport=external_port))
3955 self.pg4.add_stream(p)
3956 self.pg_enable_capture(self.pg_interfaces)
3958 capture = self.pg4.get_capture(1)
3963 self.assertEqual(ip.dst, local_host.ip4)
3964 self.assertEqual(ip.src, self.nat_addr)
3965 self.assertEqual(tcp.dport, local_port)
3966 self.assertNotEqual(tcp.sport, 12345)
3967 eh_port_in = tcp.sport
3968 self.assert_packet_checksums_valid(p)
3970 self.logger.error(ppp("Unexpected or invalid packet:", p))
3973 # from service back to client
3974 p = (Ether(src=self.pg4.remote_mac, dst=self.pg4.local_mac) /
3975 IP(src=local_host.ip4, dst=self.nat_addr) /
3976 TCP(sport=local_port, dport=eh_port_in))
3977 self.pg4.add_stream(p)
3978 self.pg_enable_capture(self.pg_interfaces)
3980 capture = self.pg4.get_capture(1)
3985 self.assertEqual(ip.src, self.nat_addr)
3986 self.assertEqual(ip.dst, remote_host.ip4)
3987 self.assertEqual(tcp.sport, external_port)
3988 self.assertEqual(tcp.dport, 12345)
3989 self.assert_packet_checksums_valid(p)
3991 self.logger.error(ppp("Unexpected or invalid packet:", p))
3994 def test_icmp_error_fwd_outbound(self):
3995 """ NAT44ED ICMP error outbound with forwarding enabled """
3997 # Ensure that an outbound ICMP error message is properly associated
3998 # with the inbound forward bypass session it is related to.
4001 self.nat_add_address(self.nat_addr)
4002 self.nat_add_inside_interface(self.pg0)
4003 self.nat_add_outside_interface(self.pg1)
4005 # enable forwarding and initiate connection out2in
4006 self.vapi.nat44_forwarding_enable_disable(enable=1)
4007 p1 = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
4008 IP(src=self.pg1.remote_ip4, dst=self.pg0.remote_ip4) /
4009 UDP(sport=21, dport=20) / payload)
4011 self.pg1.add_stream(p1)
4012 self.pg_enable_capture(self.pg_interfaces)
4014 capture = self.pg0.get_capture(1)[0]
4016 self.logger.info(self.vapi.cli("show nat44 sessions"))
4018 # reply with ICMP error message in2out
4019 # We cannot reliably retrieve forward bypass sessions via the API.
4020 # session dumps for a user will only look on the worker that the
4021 # user is supposed to be mapped to in2out. The forward bypass session
4022 # is not necessarily created on that worker.
4023 p2 = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
4024 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
4025 ICMP(type='dest-unreach', code='port-unreachable') /
4028 self.pg0.add_stream(p2)
4029 self.pg_enable_capture(self.pg_interfaces)
4031 capture = self.pg1.get_capture(1)[0]
4033 self.logger.info(self.vapi.cli("show nat44 sessions"))
4035 self.logger.info(ppp("p1 packet:", p1))
4036 self.logger.info(ppp("p2 packet:", p2))
4037 self.logger.info(ppp("capture packet:", capture))
4039 def test_tcp_session_open_retransmit1(self):
4040 """ NAT44ED Open TCP session with SYN,ACK retransmit 1
4042 The client does not receive the [SYN,ACK] or the
4043 ACK from the client is lost. Therefore, the [SYN, ACK]
4044 is retransmitted by the server.
4047 in_port = self.tcp_port_in
4048 ext_port = self.tcp_external_port
4051 self.nat_add_address(self.nat_addr)
4052 self.nat_add_inside_interface(self.pg0)
4053 self.nat_add_outside_interface(self.pg1)
4055 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
4056 tcp_transitory=5, icmp=60)
4057 # SYN packet in->out
4058 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
4059 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
4060 TCP(sport=in_port, dport=ext_port, flags="S"))
4061 p = self.send_and_expect(self.pg0, p, self.pg1)[0]
4062 out_port = p[TCP].sport
4064 # SYN + ACK packet out->in
4065 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
4066 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
4067 TCP(sport=ext_port, dport=out_port, flags="SA"))
4068 self.send_and_expect(self.pg1, p, self.pg0)
4070 # ACK in->out does not arrive
4072 # resent SYN + ACK packet out->in
4073 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
4074 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
4075 TCP(sport=ext_port, dport=out_port, flags="SA"))
4076 self.send_and_expect(self.pg1, p, self.pg0)
4078 # ACK packet in->out
4079 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
4080 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
4081 TCP(sport=in_port, dport=ext_port, flags="A"))
4082 self.send_and_expect(self.pg0, p, self.pg1)
4084 # Verify that the data can be transmitted after the transitory time
4085 self.virtual_sleep(6)
4087 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
4088 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
4089 TCP(sport=in_port, dport=ext_port, flags="PA") /
4091 self.send_and_expect(self.pg0, p, self.pg1)
4093 def test_tcp_session_open_retransmit2(self):
4094 """ NAT44ED Open TCP session with SYN,ACK retransmit 2
4096 The ACK is lost to the server after the TCP session is opened.
4097 Data is sent by the client, then the [SYN,ACK] is
4098 retransmitted by the server.
4101 in_port = self.tcp_port_in
4102 ext_port = self.tcp_external_port
4105 self.nat_add_address(self.nat_addr)
4106 self.nat_add_inside_interface(self.pg0)
4107 self.nat_add_outside_interface(self.pg1)
4109 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
4110 tcp_transitory=5, icmp=60)
4111 # SYN packet in->out
4112 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
4113 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
4114 TCP(sport=in_port, dport=ext_port, flags="S"))
4115 p = self.send_and_expect(self.pg0, p, self.pg1)[0]
4116 out_port = p[TCP].sport
4118 # SYN + ACK packet out->in
4119 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
4120 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
4121 TCP(sport=ext_port, dport=out_port, flags="SA"))
4122 self.send_and_expect(self.pg1, p, self.pg0)
4124 # ACK packet in->out -- not received by the server
4125 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
4126 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
4127 TCP(sport=in_port, dport=ext_port, flags="A"))
4128 self.send_and_expect(self.pg0, p, self.pg1)
4130 # PUSH + ACK packet in->out
4131 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
4132 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
4133 TCP(sport=in_port, dport=ext_port, flags="PA") /
4135 self.send_and_expect(self.pg0, p, self.pg1)
4137 # resent SYN + ACK packet out->in
4138 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
4139 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
4140 TCP(sport=ext_port, dport=out_port, flags="SA"))
4141 self.send_and_expect(self.pg1, p, self.pg0)
4143 # resent ACK packet in->out
4144 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
4145 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
4146 TCP(sport=in_port, dport=ext_port, flags="A"))
4147 self.send_and_expect(self.pg0, p, self.pg1)
4149 # resent PUSH + ACK packet in->out
4150 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
4151 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
4152 TCP(sport=in_port, dport=ext_port, flags="PA") /
4154 self.send_and_expect(self.pg0, p, self.pg1)
4156 # ACK packet out->in
4157 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
4158 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
4159 TCP(sport=ext_port, dport=out_port, flags="A"))
4160 self.send_and_expect(self.pg1, p, self.pg0)
4162 # Verify that the data can be transmitted after the transitory time
4163 self.virtual_sleep(6)
4165 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
4166 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
4167 TCP(sport=in_port, dport=ext_port, flags="PA") /
4169 self.send_and_expect(self.pg0, p, self.pg1)
4172 if __name__ == '__main__':
4173 unittest.main(testRunner=VppTestRunner)