import socket import unittest import ipaddress from util import ppp from asfframework import VppTestRunner from template_ipsec import IPSecIPv4Fwd from template_ipsec import IPSecIPv6Fwd from test_ipsec_esp import TemplateIpsecEsp from template_ipsec import SpdFastPathTemplate def debug_signal_handler(signal, frame): import pdb pdb.set_trace() import signal signal.signal(signal.SIGINT, debug_signal_handler) class SpdFastPathInbound(SpdFastPathTemplate): # In test cases derived from this class, packets in IPv4 FWD path # are configured to go through IPSec inbound SPD policy lookup. # Note that order in which the rules are applied is # PROTECT, BYPASS, DISCARD. Therefore BYPASS rules take # precedence over DISCARD. # # Override setUpConstants to enable inbound fast path in config @classmethod def setUpConstants(cls): super(SpdFastPathInbound, cls).setUpConstants() cls.vpp_cmdline.extend(["ipsec", "{", "ipv4-inbound-spd-fast-path on", "}"]) cls.logger.info("VPP modified cmdline is %s" % " ".join(cls.vpp_cmdline)) class SpdFastPathInboundProtect(TemplateIpsecEsp): @classmethod def setUpConstants(cls): super(SpdFastPathInboundProtect, cls).setUpConstants() cls.vpp_cmdline.extend(["ipsec", "{", "ipv4-inbound-spd-fast-path on", "}"]) cls.logger.info("VPP modified cmdline is %s" % " ".join(cls.vpp_cmdline)) @classmethod def setUpClass(cls): super(SpdFastPathInboundProtect, cls).setUpClass() @classmethod def tearDownClass(cls): super(SpdFastPathInboundProtect, cls).tearDownClass() def setUp(self): super(SpdFastPathInboundProtect, self).setUp() def tearDown(self): self.unconfig_network() super(SpdFastPathInboundProtect, self).tearDown() class SpdFastPathIPv6Inbound(IPSecIPv6Fwd): # In test cases derived from this class, packets in IPvr6 FWD path # are configured to go through IPSec inbound SPD policy lookup. # Note that order in which the rules are applied is # PROTECT, BYPASS, DISCARD. Therefore BYPASS rules take # precedence over DISCARDi. # Override setUpConstants to enable inbound fast path in config @classmethod def setUpConstants(cls): super(SpdFastPathIPv6Inbound, cls).setUpConstants() cls.vpp_cmdline.extend(["ipsec", "{", "ipv6-inbound-spd-fast-path on", "}"]) cls.logger.info("VPP modified cmdline is %s" % " ".join(cls.vpp_cmdline)) class SpdFastPathIPv6InboundProtect(TemplateIpsecEsp): @classmethod def setUpConstants(cls): super(SpdFastPathIPv6InboundProtect, cls).setUpConstants() cls.vpp_cmdline.extend(["ipsec", "{", "ipv6-inbound-spd-fast-path on", "}"]) cls.logger.info("VPP modified cmdline is %s" % " ".join(cls.vpp_cmdline)) @classmethod def setUpClass(cls): super(SpdFastPathIPv6InboundProtect, cls).setUpClass() @classmethod def tearDownClass(cls): super(SpdFastPathIPv6InboundProtect, cls).tearDownClass() def setUp(self): super(SpdFastPathIPv6InboundProtect, self).setUp() def tearDown(self): self.unconfig_network() super(SpdFastPathIPv6InboundProtect, self).tearDown() class IPSec4SpdTestCaseBypass(SpdFastPathInbound): """ IPSec/IPv4 inbound: Policy mode test case with fast path \ (add bypass)""" def test_ipsec_spd_inbound_bypass(self): # In this test case, packets in IPv4 FWD path are configured # to go through IPSec inbound SPD policy lookup. # # 2 inbound SPD rules (1 HIGH and 1 LOW) are added. # - High priority rule action is set to DISCARD. # - Low priority rule action is set to BYPASS. # # Since BYPASS rules take precedence over DISCARD # (the order being PROTECT, BYPASS, DISCARD) we expect the # BYPASS rule to match and traffic to be correctly forwarded. self.create_interfaces(2) pkt_count = 5 self.spd_create_and_intf_add(1, [self.pg1, self.pg0]) # create input rules # bypass rule should take precedence over discard rule, # even though it's lower priority, because for input policies # matching PROTECT policies precedes matching BYPASS policies # which preceeds matching for DISCARD policies. # Any hit stops the process. policy_0 = self.spd_add_rem_policy( # inbound, priority 10 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="bypass", ip_range=True, local_ip_start=self.pg1.remote_ip4, local_ip_stop=self.pg1.remote_ip4, remote_ip_start=self.pg0.remote_ip4, remote_ip_stop=self.pg0.remote_ip4, ) policy_1 = self.spd_add_rem_policy( # inbound, priority 15 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=15, policy_type="discard", ip_range=True, local_ip_start=self.pg1.remote_ip4, local_ip_stop=self.pg1.remote_ip4, remote_ip_start=self.pg0.remote_ip4, remote_ip_stop=self.pg0.remote_ip4, ) # create output rule so we can capture forwarded packets policy_2 = self.spd_add_rem_policy( # outbound, priority 10 1, self.pg0, self.pg1, socket.IPPROTO_UDP, is_out=1, priority=10, policy_type="bypass", ) # create the packet stream packets = self.create_stream(self.pg0, self.pg1, pkt_count) # add the stream to the source interface self.pg0.add_stream(packets) self.pg1.enable_capture() self.pg_start() # check capture on pg1 capture = self.pg1.get_capture() for packet in capture: try: self.logger.debug(ppp("SPD Add - Got packet:", packet)) except Exception: self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise self.logger.debug("SPD: Num packets: %s", len(capture.res)) # verify captured packets self.verify_capture(self.pg0, self.pg1, capture) # verify all policies matched the expected number of times self.verify_policy_match(pkt_count, policy_0) self.verify_policy_match(0, policy_1) self.verify_policy_match(pkt_count, policy_2) class IPSec4SpdTestCaseDiscard(SpdFastPathInbound): """ IPSec/IPv4 inbound: Policy mode test case with fast path \ (add discard)""" def test_ipsec_spd_inbound_discard(self): # In this test case, packets in IPv4 FWD path are configured # to go through IPSec inbound SPD policy lookup. # # Rule action is set to DISCARD. self.create_interfaces(2) pkt_count = 5 self.spd_create_and_intf_add(1, [self.pg1, self.pg0]) # create input rules # bypass rule should take precedence over discard rule, # even though it's lower priority policy_0 = self.spd_add_rem_policy( # inbound, priority 10 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="discard", ) # create output rule so we can capture forwarded packets policy_1 = self.spd_add_rem_policy( # outbound, priority 10 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=1, priority=10, policy_type="bypass", ) # create the packet stream packets = self.create_stream(self.pg0, self.pg1, pkt_count) # add the stream to the source interface self.pg0.add_stream(packets) self.pg1.enable_capture() self.pg_start() # check capture on pg1 capture = self.pg1.assert_nothing_captured() # verify all policies matched the expected number of times self.verify_policy_match(pkt_count, policy_0) self.verify_policy_match(0, policy_1) class IPSec4SpdTestCaseProtect(SpdFastPathInboundProtect): """ IPSec/IPv4 inbound: Policy mode test case with fast path \ (add protect)""" @classmethod def setUpClass(cls): super(IPSec4SpdTestCaseProtect, cls).setUpClass() @classmethod def tearDownClass(cls): super(IPSec4SpdTestCaseProtect, cls).tearDownClass() def setUp(self): super(IPSec4SpdTestCaseProtect, self).setUp() def tearDown(self): super(IPSec4SpdTestCaseProtect, self).tearDown() def test_ipsec_spd_inbound_protect(self): # In this test case, encrypted packets in IPv4 # PROTECT path are configured # to go through IPSec inbound SPD policy lookup. pkt_count = 5 payload_size = 64 p = self.params[socket.AF_INET] send_pkts = self.gen_encrypt_pkts( p, p.scapy_tra_sa, self.tra_if, src=self.tra_if.remote_ip4, dst=self.tra_if.local_ip4, count=pkt_count, payload_size=payload_size, ) recv_pkts = self.send_and_expect(self.tra_if, send_pkts, self.tra_if) self.logger.info(self.vapi.ppcli("show error")) self.logger.info(self.vapi.ppcli("show ipsec all")) pkts = p.tra_sa_in.get_stats()["packets"] self.assertEqual( pkts, pkt_count, "incorrect SA in counts: expected %d != %d" % (pkt_count, pkts), ) pkts = p.tra_sa_out.get_stats()["packets"] self.assertEqual( pkts, pkt_count, "incorrect SA out counts: expected %d != %d" % (pkt_count, pkts), ) self.assertEqual(p.tra_sa_out.get_err("lost"), 0) self.assertEqual(p.tra_sa_in.get_err("lost"), 0) class IPSec4SpdTestCaseAddIPRange(SpdFastPathInbound): """ IPSec/IPv4 inbound: Policy mode test case with fast path \ (add ips range with any port rule)""" def test_ipsec_spd_inbound_add(self): # In this test case, packets in IPv4 FWD path are configured # to go through IPSec inbound SPD policy lookup. # 2 SPD bypass rules (1 for inbound and 1 for outbound) are added. # Traffic sent on pg0 interface should match fast path priority # rule and should be sent out on pg1 interface. self.create_interfaces(2) pkt_count = 5 s_ip_s1 = ipaddress.ip_address(self.pg0.remote_ip4) s_ip_e1 = ipaddress.ip_address(int(s_ip_s1) + 5) d_ip_s1 = ipaddress.ip_address(self.pg1.remote_ip4) d_ip_e1 = ipaddress.ip_address(int(d_ip_s1) + 0) s_ip_s0 = ipaddress.ip_address(self.pg0.remote_ip4) s_ip_e0 = ipaddress.ip_address(int(s_ip_s0) + 6) d_ip_s0 = ipaddress.ip_address(self.pg1.remote_ip4) d_ip_e0 = ipaddress.ip_address(int(d_ip_s0) + 0) self.spd_create_and_intf_add(1, [self.pg1, self.pg0]) policy_0 = self.spd_add_rem_policy( # inbound fast path, priority 10 1, self.pg0, self.pg1, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="bypass", ip_range=True, local_ip_start=d_ip_s0, local_ip_stop=d_ip_e0, remote_ip_start=s_ip_s0, remote_ip_stop=s_ip_e0, ) policy_1 = self.spd_add_rem_policy( # outbound, priority 5 1, self.pg0, self.pg1, socket.IPPROTO_UDP, is_out=1, priority=5, policy_type="bypass", ip_range=True, local_ip_start=s_ip_s1, local_ip_stop=s_ip_e1, remote_ip_start=d_ip_s1, remote_ip_stop=d_ip_e1, ) # create the packet stream packets = self.create_stream(self.pg0, self.pg1, pkt_count) # add the stream to the source interface + enable capture self.pg0.add_stream(packets) self.pg0.enable_capture() self.pg1.enable_capture() # start the packet generator self.pg_start() # get capture capture = self.pg1.get_capture() for packet in capture: try: self.logger.debug(ppp("SPD - Got packet:", packet)) except Exception: self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise self.logger.debug("SPD: Num packets: %s", len(capture.res)) # assert nothing captured on pg0 self.pg0.assert_nothing_captured() # verify captured packets self.verify_capture(self.pg0, self.pg1, capture) # verify all policies matched the expected number of times self.verify_policy_match(pkt_count, policy_0) self.verify_policy_match(pkt_count, policy_1) class IPSec4SpdTestCaseAddAll(SpdFastPathInbound): """ IPSec/IPv4 inbound: Policy mode test case with fast path \ (add all ips ports rule)""" def test_ipsec_spd_inbound_add(self): # In this test case, packets in IPv4 FWD path are configured # to go through IPSec inbound SPD policy lookup. # 2 SPD rules (1 HIGH and 1 LOW) are added. # Low priority rule action is set to BYPASS all ips. # High priority rule action is set to DISCARD all ips. # Traffic not sent on pg0 interface when HIGH discard priority rule is added. # Then LOW priority # rule is added and send the same traffic to pg0, this time expect # the traffic is bypassed as bypass takes priority over discard. self.create_interfaces(2) pkt_count = 5 self.spd_create_and_intf_add(1, [self.pg0, self.pg1]) policy_0 = self.spd_add_rem_policy( # inbound, priority 20 1, self.pg0, self.pg1, socket.IPPROTO_UDP, is_out=0, priority=20, policy_type="discard", all_ips=True, ) policy_1 = self.spd_add_rem_policy( # inbound, priority 20 1, self.pg0, self.pg1, socket.IPPROTO_UDP, is_out=True, priority=5, policy_type="bypass", all_ips=True, ) # create the packet stream packets = self.create_stream(self.pg0, self.pg1, pkt_count) # add the stream to the source interface + enable capture self.pg0.add_stream(packets) self.pg0.enable_capture() self.pg1.enable_capture() # start the packet generator self.pg_start() # assert nothing captured on pg0 and pg1 self.pg0.assert_nothing_captured() self.pg1.assert_nothing_captured() policy_2 = self.spd_add_rem_policy( # inbound, priority 10 1, self.pg0, self.pg1, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="bypass", all_ips=True, ) # create the packet stream packets = self.create_stream(self.pg0, self.pg1, pkt_count) # add the stream to the source interface + enable capture self.pg0.add_stream(packets) self.pg0.enable_capture() self.pg1.enable_capture() # start the packet generator self.pg_start() # get capture capture = self.pg1.get_capture(expected_count=pkt_count) for packet in capture: try: self.logger.debug(ppp("SPD - Got packet:", packet)) except Exception: self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise self.logger.debug("SPD: Num packets: %s", len(capture.res)) # assert nothing captured on pg0 self.pg0.assert_nothing_captured() # verify all policies matched the expected number of times self.verify_policy_match(pkt_count, policy_2) class IPSec4SpdTestCaseRemove(SpdFastPathInbound): """ IPSec/IPv4 inbound: Policy mode test case with fast path \ (remove rule)""" def test_ipsec_spd_inbound_remove(self): # In this test case, packets in IPv4 FWD path are configured # to go through IPSec inbound SPD policy lookup. # 2 SPD rules (1 HIGH and 1 LOW) are added. # High priority rule action is set to BYPASS. # Low priority rule action is set to DISCARD. # High priority rule is then removed. # Traffic sent on pg0 interface should match low priority # rule and should be discarded after SPD lookup. self.create_interfaces(2) pkt_count = 5 self.spd_create_and_intf_add(1, [self.pg0, self.pg1]) policy_0 = self.spd_add_rem_policy( # inbound, priority 10 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="bypass", ) policy_1 = self.spd_add_rem_policy( # inbound, priority 5 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=5, policy_type="discard", ) policy_out = self.spd_add_rem_policy( # outbound, priority 10 1, self.pg0, self.pg1, socket.IPPROTO_UDP, is_out=1, priority=10, policy_type="bypass", ) # create the packet stream packets = self.create_stream(self.pg0, self.pg1, pkt_count) # add the stream to the source interface + enable capture self.pg0.add_stream(packets) self.pg0.enable_capture() self.pg1.enable_capture() # start the packet generator self.pg_start() # get capture capture = self.pg1.get_capture() for packet in capture: try: self.logger.debug(ppp("SPD - Got packet:", packet)) except Exception: self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise # assert nothing captured on pg0 self.pg0.assert_nothing_captured() # verify capture on pg1 self.logger.debug("SPD: Num packets: %s", len(capture.res)) self.verify_capture(self.pg0, self.pg1, capture) # verify all policies matched the expected number of times self.verify_policy_match(pkt_count, policy_0) self.verify_policy_match(0, policy_1) # now remove the bypass rule self.spd_add_rem_policy( # outbound, priority 10 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="bypass", remove=True, ) # resend the same packets self.pg0.add_stream(packets) self.pg0.enable_capture() # flush the old captures self.pg1.enable_capture() self.pg_start() # assert nothing captured on pg0 self.pg0.assert_nothing_captured() # all packets will be dropped by SPD rule self.pg1.assert_nothing_captured() # verify all policies matched the expected number of times self.verify_policy_match(pkt_count, policy_0) self.verify_policy_match(pkt_count, policy_1) class IPSec4SpdTestCaseReadd(SpdFastPathInbound): """ IPSec/IPv4 inbound: Policy mode test case with fast path \ (add, remove, re-add)""" def test_ipsec_spd_inbound_readd(self): # In this test case, packets in IPv4 FWD path are configured # to go through IPSec outbound SPD policy lookup. # 2 SPD rules (1 HIGH and 1 LOW) are added. # High priority rule action is set to BYPASS. # Low priority rule action is set to DISCARD. # Traffic sent on pg0 interface should match high priority # rule and should be sent out on pg1 interface. # High priority rule is then removed. # Traffic sent on pg0 interface should match low priority # rule and should be discarded after SPD lookup. # Readd high priority rule. # Traffic sent on pg0 interface should match high priority # rule and should be sent out on pg1 interface. self.create_interfaces(2) pkt_count = 5 self.spd_create_and_intf_add(1, [self.pg0, self.pg1]) policy_0 = self.spd_add_rem_policy( # inbound, priority 10 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="bypass", ) policy_1 = self.spd_add_rem_policy( # inbound, priority 5 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=5, policy_type="discard", ) policy_2 = self.spd_add_rem_policy( # outbound, priority 10 1, self.pg0, self.pg1, socket.IPPROTO_UDP, is_out=1, priority=10, policy_type="bypass", ) # create the packet stream packets = self.create_stream(self.pg0, self.pg1, pkt_count) # add the stream to the source interface + enable capture self.pg0.add_stream(packets) self.pg0.enable_capture() self.pg1.enable_capture() # start the packet generator self.pg_start() # get capture capture = self.pg1.get_capture() for packet in capture: try: self.logger.debug(ppp("SPD - Got packet:", packet)) except Exception: self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise self.logger.debug("SPD: Num packets: %s", len(capture.res)) # assert nothing captured on pg0 self.pg0.assert_nothing_captured() # verify capture on pg1 self.verify_capture(self.pg0, self.pg1, capture) # verify all policies matched the expected number of times self.verify_policy_match(pkt_count, policy_0) self.verify_policy_match(0, policy_1) # remove the bypass rule, leaving only the discard rule self.spd_add_rem_policy( # inbound, priority 10 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="bypass", remove=True, ) # resend the same packets self.pg0.add_stream(packets) self.pg0.enable_capture() # flush the old captures self.pg1.enable_capture() self.pg_start() # assert nothing captured on pg0 self.pg0.assert_nothing_captured() # all packets will be dropped by SPD rule self.pg1.assert_nothing_captured() # verify all policies matched the expected number of times self.verify_policy_match(pkt_count, policy_0) self.verify_policy_match(pkt_count, policy_1) # now readd the bypass rule policy_0 = self.spd_add_rem_policy( # outbound, priority 10 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="bypass", ) # resend the same packets self.pg0.add_stream(packets) self.pg0.enable_capture() # flush the old captures self.pg1.enable_capture() self.pg_start() # get capture capture = self.pg1.get_capture(pkt_count) for packet in capture: try: self.logger.debug(ppp("SPD - Got packet:", packet)) except Exception: self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise self.logger.debug("SPD: Num packets: %s", len(capture.res)) # assert nothing captured on pg0 self.pg0.assert_nothing_captured() # verify captured packets self.verify_capture(self.pg0, self.pg1, capture) # verify all policies matched the expected number of times self.verify_policy_match(pkt_count, policy_0) self.verify_policy_match(pkt_count, policy_1) class IPSec4SpdTestCaseMultiple(SpdFastPathInbound): """ IPSec/IPv4 inbound: Policy mode test case with fast path \ (multiple interfaces, multiple rules)""" def test_ipsec_spd_inbound_multiple(self): # In this test case, packets in IPv4 FWD path are configured to go # through IPSec outbound SPD policy lookup. # Multiples rules on multiple interfaces are tested at the same time. # 3x interfaces are configured, binding the same SPD to each. # Each interface has 2 SPD rules (1 BYPASS and 1 DISCARD). # On pg0 & pg1, the BYPASS rule is HIGH priority # On pg2, the DISCARD rule is HIGH priority # Traffic should be received on pg0 & pg1 and dropped on pg2. self.create_interfaces(3) pkt_count = 5 # bind SPD to all interfaces self.spd_create_and_intf_add(1, self.pg_interfaces) # add rules on all interfaces policy_01 = self.spd_add_rem_policy( # inbound, priority 10 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="bypass", ) policy_02 = self.spd_add_rem_policy( # inbound, priority 5 1, self.pg1, self.pg0, socket.IPPROTO_UDP, is_out=0, priority=5, policy_type="discard", ) policy_11 = self.spd_add_rem_policy( # inbound, priority 10 1, self.pg2, self.pg1, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="bypass", ) policy_12 = self.spd_add_rem_policy( # inbound, priority 5 1, self.pg2, self.pg1, socket.IPPROTO_UDP, is_out=0, priority=5, policy_type="discard", ) policy_21 = self.spd_add_rem_policy( # inbound, priority 5 1, self.pg0, self.pg2, socket.IPPROTO_UDP, is_out=0, priority=5, policy_type="bypass", ) policy_22 = self.spd_add_rem_policy( # inbound, priority 10 1, self.pg0, self.pg2, socket.IPPROTO_UDP, is_out=0, priority=10, policy_type="discard", ) # interfaces bound to an SPD, will by default drop outbound # traffic with no matching policies. add catch-all outbound # bypass rule to SPD: self.spd_add_rem_policy( # outbound, all interfaces 1, None, None, socket.IPPROTO_UDP, is_out=1, priority=10, policy_type="bypass", all_ips=True, ) # create the packet streams packets0 = self.create_stream(self.pg0, self.pg1, pkt_count) packets1 = self.create_stream(self.pg1, self.pg2, pkt_count) packets2 = self.create_stream(self.pg2, self.pg0, pkt_count) # add the streams to the source interfaces self.pg0.add_stream(packets0) self.pg1.add_stream(packets1) self.pg2.add_stream(packets2) # enable capture on all interfaces for pg in self.pg_interfaces: pg.enable_capture() # start the packet generator self.pg_start() # get captures if_caps = [] for pg in [self.pg1, self.pg2]: # we are expecting captures on pg1/pg2 if_caps.append(pg.get_capture()) for packet in if_caps[-1]: try: self.logger.debug(ppp("SPD - Got packet:", packet)) except Exception: self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise self.logger.debug("SPD: Num packets: %s", len(if_caps[0].res)) self.logger.debug("SPD: Num packets: %s", len(if_caps[1].res)) # verify captures that matched BYPASS rule self.verify_capture(self.pg0, self.pg1, if_caps[0]) self.verify_capture(self.pg1, self.pg2, if_caps[1]) # verify that traffic to pg0 matched BYPASS rule # although DISCARD rule had higher prioriy and was not dropped self.verify_policy_match(pkt_count, policy_21) # verify all packets that were expected to match rules, matched # pg0 -> pg1 self.verify_policy_match(pkt_count, policy_01) self.verify_policy_match(0, policy_02) # pg1 -> pg2 self.verify_policy_match(pkt_count, policy_11) self.verify_policy_match(0, policy_12) # pg2 -> pg0 self.verify_policy_match(0, policy_22) class IPSec6SpdTestCaseProtect(SpdFastPathIPv6InboundProtect): """ IPSec/IPv6 inbound: Policy mode test case with fast path \ (add protect)""" @classmethod def setUpClass(cls): super(IPSec6SpdTestCaseProtect, cls).setUpClass() @classmethod def tearDownClass(cls): super(IPSec6SpdTestCaseProtect, cls).tearDownClass() def setUp(self): super(IPSec6SpdTestCaseProtect, self).setUp() def tearDown(self): super(IPSec6SpdTestCaseProtect, self).tearDown() def test_ipsec6_spd_inbound_protect(self): pkt_count = 5 payload_size = 64 p = self.params[socket.AF_INET6] send_pkts = self.gen_encrypt_pkts6( p, p.scapy_tra_sa, self.tra_if, src=self.tra_if.remote_ip6, dst=self.tra_if.local_ip6, count=pkt_count, payload_size=payload_size, ) recv_pkts = self.send_and_expect(self.tra_if, send_pkts, self.tra_if) self.logger.info(self.vapi.ppcli("show error")) self.logger.info(self.vapi.ppcli("show ipsec all")) pkts = p.tra_sa_in.get_stats()["packets"] self.assertEqual( pkts, pkt_count, "incorrect SA in counts: expected %d != %d" % (pkt_count, pkts), ) pkts = p.tra_sa_out.get_stats()["packets"] self.assertEqual( pkts, pkt_count, "incorrect SA out counts: expected %d != %d" % (pkt_count, pkts), ) self.assertEqual(p.tra_sa_out.get_err("lost"), 0) self.assertEqual(p.tra_sa_in.get_err("lost"), 0) if __name__ == "__main__": unittest.main(testRunner=VppTestRunner)