CSIT-1506: Rework IPsec base testcases
[csit.git] / resources / libraries / python / IPsecUtil.py
1 # Copyright (c) 2019 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
5 #
6 #     http://www.apache.org/licenses/LICENSE-2.0
7 #
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
13
14 """IPsec utilities library."""
15
16 import os
17 from ipaddress import ip_network, ip_address
18
19 from enum import Enum, IntEnum
20
21 from resources.libraries.python.PapiExecutor import PapiExecutor
22 from resources.libraries.python.topology import Topology
23 from resources.libraries.python.VatExecutor import VatExecutor
24 from resources.libraries.python.VatJsonUtil import VatJsonUtil
25
26
27 class PolicyAction(Enum):
28     """Policy actions."""
29     BYPASS = 'bypass'
30     DISCARD = 'discard'
31     PROTECT = 'protect'
32
33     def __init__(self, string):
34         self.string = string
35
36
37 class CryptoAlg(Enum):
38     """Encryption algorithms."""
39     AES_CBC_128 = ('aes-cbc-128', 'AES-CBC', 16)
40     AES_CBC_192 = ('aes-cbc-192', 'AES-CBC', 24)
41     AES_CBC_256 = ('aes-cbc-256', 'AES-CBC', 32)
42     AES_GCM_128 = ('aes-gcm-128', 'AES-GCM', 20)
43     AES_GCM_256 = ('aes-gcm-256', 'AES-GCM', 40)
44
45     def __init__(self, alg_name, scapy_name, key_len):
46         self.alg_name = alg_name
47         self.scapy_name = scapy_name
48         self.key_len = key_len
49
50
51 class IntegAlg(Enum):
52     """Integrity algorithm."""
53     SHA1_96 = ('sha1-96', 'HMAC-SHA1-96', 20)
54     SHA_256_128 = ('sha-256-128', 'SHA2-256-128', 32)
55     SHA_384_192 = ('sha-384-192', 'SHA2-384-192', 48)
56     SHA_512_256 = ('sha-512-256', 'SHA2-512-256', 64)
57     AES_GCM_128 = ('aes-gcm-128', 'AES-GCM', 20)
58     AES_GCM_256 = ('aes-gcm-256', 'AES-GCM', 40)
59
60     def __init__(self, alg_name, scapy_name, key_len):
61         self.alg_name = alg_name
62         self.scapy_name = scapy_name
63         self.key_len = key_len
64
65
66 class IPsecProto(IntEnum):
67     """IPsec protocol."""
68     ESP = 1
69     SEC_AH = 0
70
71
72 class IPsecUtil(object):
73     """IPsec utilities."""
74
75     @staticmethod
76     def policy_action_bypass():
77         """Return policy action bypass.
78
79         :returns: PolicyAction enum BYPASS object.
80         :rtype: PolicyAction
81         """
82         return PolicyAction.BYPASS
83
84     @staticmethod
85     def policy_action_discard():
86         """Return policy action discard.
87
88         :returns: PolicyAction enum DISCARD object.
89         :rtype: PolicyAction
90         """
91         return PolicyAction.DISCARD
92
93     @staticmethod
94     def policy_action_protect():
95         """Return policy action protect.
96
97         :returns: PolicyAction enum PROTECT object.
98         :rtype: PolicyAction
99         """
100         return PolicyAction.PROTECT
101
102     @staticmethod
103     def crypto_alg_aes_cbc_128():
104         """Return encryption algorithm aes-cbc-128.
105
106         :returns: CryptoAlg enum AES_CBC_128 object.
107         :rtype: CryptoAlg
108         """
109         return CryptoAlg.AES_CBC_128
110
111     @staticmethod
112     def crypto_alg_aes_cbc_192():
113         """Return encryption algorithm aes-cbc-192.
114
115         :returns: CryptoAlg enum AES_CBC_192 objec.
116         :rtype: CryptoAlg
117         """
118         return CryptoAlg.AES_CBC_192
119
120     @staticmethod
121     def crypto_alg_aes_cbc_256():
122         """Return encryption algorithm aes-cbc-256.
123
124         :returns: CryptoAlg enum AES_CBC_256 object.
125         :rtype: CryptoAlg
126         """
127         return CryptoAlg.AES_CBC_256
128
129     @staticmethod
130     def crypto_alg_aes_gcm_128():
131         """Return encryption algorithm aes-gcm-128.
132
133         :returns: CryptoAlg enum AES_GCM_128 object.
134         :rtype: CryptoAlg
135         """
136         return CryptoAlg.AES_GCM_128
137
138     @staticmethod
139     def crypto_alg_aes_gcm_256():
140         """Return encryption algorithm aes-gcm-256.
141
142         :returns: CryptoAlg enum AES_GCM_128 object.
143         :rtype: CryptoAlg
144         """
145         return CryptoAlg.AES_GCM_256
146
147     @staticmethod
148     def get_crypto_alg_key_len(crypto_alg):
149         """Return encryption algorithm key length.
150
151         :param crypto_alg: Encryption algorithm.
152         :type crypto_alg: CryptoAlg
153         :returns: Key length.
154         :rtype: int
155         """
156         return crypto_alg.key_len
157
158     @staticmethod
159     def get_crypto_alg_scapy_name(crypto_alg):
160         """Return encryption algorithm scapy name.
161
162         :param crypto_alg: Encryption algorithm.
163         :type crypto_alg: CryptoAlg
164         :returns: Algorithm scapy name.
165         :rtype: str
166         """
167         return crypto_alg.scapy_name
168
169     @staticmethod
170     def integ_alg_sha1_96():
171         """Return integrity algorithm SHA1-96.
172
173         :returns: IntegAlg enum SHA1_96 object.
174         :rtype: IntegAlg
175         """
176         return IntegAlg.SHA1_96
177
178     @staticmethod
179     def integ_alg_sha_256_128():
180         """Return integrity algorithm SHA-256-128.
181
182         :returns: IntegAlg enum SHA_256_128 object.
183         :rtype: IntegAlg
184         """
185         return IntegAlg.SHA_256_128
186
187     @staticmethod
188     def integ_alg_sha_384_192():
189         """Return integrity algorithm SHA-384-192.
190
191         :returns: IntegAlg enum SHA_384_192 object.
192         :rtype: IntegAlg
193         """
194         return IntegAlg.SHA_384_192
195
196     @staticmethod
197     def integ_alg_sha_512_256():
198         """Return integrity algorithm SHA-512-256.
199
200         :returns: IntegAlg enum SHA_512_256 object.
201         :rtype: IntegAlg
202         """
203         return IntegAlg.SHA_512_256
204
205     @staticmethod
206     def integ_alg_aes_gcm_128():
207         """Return integrity algorithm AES-GCM-128.
208
209         :returns: IntegAlg enum AES_GCM_128 object.
210         :rtype: IntegAlg
211         """
212         return IntegAlg.AES_GCM_128
213
214     @staticmethod
215     def integ_alg_aes_gcm_256():
216         """Return integrity algorithm AES-GCM-256.
217
218         :returns: IntegAlg enum AES_GCM_256 object.
219         :rtype: IntegAlg
220         """
221         return IntegAlg.AES_GCM_256
222
223     @staticmethod
224     def get_integ_alg_key_len(integ_alg):
225         """Return integrity algorithm key length.
226
227         :param integ_alg: Integrity algorithm.
228         :type integ_alg: IntegAlg
229         :returns: Key length.
230         :rtype: int
231         """
232         return integ_alg.key_len
233
234     @staticmethod
235     def get_integ_alg_scapy_name(integ_alg):
236         """Return integrity algorithm scapy name.
237
238         :param integ_alg: Integrity algorithm.
239         :type integ_alg: IntegAlg
240         :returns: Algorithm scapy name.
241         :rtype: str
242         """
243         return integ_alg.scapy_name
244
245     @staticmethod
246     def ipsec_proto_esp():
247         """Return IPSec protocol ESP.
248
249         :returns: IPsecProto enum ESP object.
250         :rtype: IPsecProto
251         """
252         return int(IPsecProto.ESP)
253
254     @staticmethod
255     def ipsec_proto_ah():
256         """Return IPSec protocol AH.
257
258         :returns: IPsecProto enum AH object.
259         :rtype: IPsecProto
260         """
261         return int(IPsecProto.SEC_AH)
262
263     @staticmethod
264     def vpp_ipsec_select_backend(node, protocol, index=1):
265         """Select IPsec backend.
266
267         :param node: VPP node to select IPsec backend on.
268         :param protocol: IPsec protocol.
269         :param index: Backend index.
270         :type node: dict
271         :type protocol: IPsecProto
272         :type index: int
273         :raises RuntimeError: If failed to select IPsec backend or if no API
274             reply received.
275         """
276
277         cmd = 'ipsec_select_backend'
278         cmd_reply = 'ipsec_select_backend_reply'
279         err_msg = 'Failed to select IPsec backend on host {host}'.format(
280             host=node['host'])
281         args = dict(protocol=protocol, index=index)
282         with PapiExecutor(node) as papi_exec:
283             papi_resp = papi_exec.add(cmd, **args).execute_should_pass(err_msg)
284         data = papi_resp.reply[0]['api_reply'][cmd_reply]
285         if data['retval'] != 0:
286             raise RuntimeError('Failed to select IPsec backend on host {host}'.
287                                format(host=node['host']))
288
289     @staticmethod
290     def vpp_ipsec_backend_dump(node):
291         """Dump IPsec backends.
292
293         :param node: VPP node to dump IPsec backend on.
294         :type node: dict
295         """
296
297         err_msg = 'Failed to dump IPsec backends on host {host}'.format(
298             host=node['host'])
299         with PapiExecutor(node) as papi_exec:
300             papi_exec.add('ipsec_backend_dump').execute_should_pass(
301                 err_msg, process_reply=False)
302
303     @staticmethod
304     def vpp_ipsec_add_sad_entry(node, sad_id, spi, crypto_alg, crypto_key,
305                                 integ_alg, integ_key, tunnel_src=None,
306                                 tunnel_dst=None):
307         """Create Security Association Database entry on the VPP node.
308
309         :param node: VPP node to add SAD entry on.
310         :param sad_id: SAD entry ID.
311         :param spi: Security Parameter Index of this SAD entry.
312         :param crypto_alg: The encryption algorithm name.
313         :param crypto_key: The encryption key string.
314         :param integ_alg: The integrity algorithm name.
315         :param integ_key: The integrity key string.
316         :param tunnel_src: Tunnel header source IPv4 or IPv6 address. If not
317             specified ESP transport mode is used.
318         :param tunnel_dst: Tunnel header destination IPv4 or IPv6 address. If
319             not specified ESP transport mode is used.
320         :type node: dict
321         :type sad_id: int
322         :type spi: int
323         :type crypto_alg: CryptoAlg
324         :type crypto_key: str
325         :type integ_alg: IntegAlg
326         :type integ_key: str
327         :type tunnel_src: str
328         :type tunnel_dst: str
329         """
330         ckey = crypto_key.encode('hex')
331         ikey = integ_key.encode('hex')
332         tunnel = 'tunnel-src {0} tunnel-dst {1}'.format(tunnel_src, tunnel_dst)\
333             if tunnel_src is not None and tunnel_dst is not None else ''
334
335         out = VatExecutor.cmd_from_template(node,
336                                             'ipsec/ipsec_sad_add_entry.vat',
337                                             sad_id=sad_id, spi=spi,
338                                             calg=crypto_alg.alg_name, ckey=ckey,
339                                             ialg=integ_alg.alg_name, ikey=ikey,
340                                             tunnel=tunnel)
341         VatJsonUtil.verify_vat_retval(
342             out[0],
343             err_msg='Add SAD entry failed on {0}'.format(node['host']))
344
345     @staticmethod
346     def vpp_ipsec_add_sad_entries(node, n_entries, sad_id, spi, crypto_alg,
347                                   crypto_key, integ_alg, integ_key,
348                                   tunnel_src=None, tunnel_dst=None):
349         """Create multiple Security Association Database entries on VPP node.
350
351         :param node: VPP node to add SAD entry on.
352         :param n_entries: Number of SAD entries to be created.
353         :param sad_id: First SAD entry ID. All subsequent SAD entries will have
354             id incremented by 1.
355         :param spi: Security Parameter Index of first SAD entry. All subsequent
356             SAD entries will have spi incremented by 1.
357         :param crypto_alg: The encryption algorithm name.
358         :param crypto_key: The encryption key string.
359         :param integ_alg: The integrity algorithm name.
360         :param integ_key: The integrity key string.
361         :param tunnel_src: Tunnel header source IPv4 or IPv6 address. If not
362             specified ESP transport mode is used.
363         :param tunnel_dst: Tunnel header destination IPv4 or IPv6 address. If
364             not specified ESP transport mode is used.
365         :type node: dict
366         :type n_entries: int
367         :type sad_id: int
368         :type spi: int
369         :type crypto_alg: CryptoAlg
370         :type crypto_key: str
371         :type integ_alg: IntegAlg
372         :type integ_key: str
373         :type tunnel_src: str
374         :type tunnel_dst: str
375         """
376         tmp_filename = '/tmp/ipsec_sad_{0}_add_del_entry.script'.format(sad_id)
377         ckey = crypto_key.encode('hex')
378         ikey = integ_key.encode('hex')
379         tunnel = 'tunnel-src {0} tunnel-dst {1}'.format(tunnel_src, tunnel_dst)\
380             if tunnel_src is not None and tunnel_dst is not None else ''
381
382         integ = 'integ-alg {0} integ-key {1}'.format(integ_alg.alg_name, ikey)\
383             if crypto_alg.alg_name != 'aes-gcm-128' and \
384                crypto_alg.alg_name != 'aes-gcm-256' else ''
385
386         with open(tmp_filename, 'w') as tmp_file:
387             for i in range(0, n_entries):
388                 buf_str = 'exec ipsec sa add {0} esp spi {1} ' \
389                           'crypto-alg {2} crypto-key {3} {4} {5}\n'.format(
390                               sad_id+i, spi+i, crypto_alg.alg_name, ckey, integ,
391                               tunnel)
392                 tmp_file.write(buf_str)
393         vat = VatExecutor()
394         vat.execute_script(tmp_filename, node, timeout=300, json_out=False,
395                            copy_on_execute=True)
396         os.remove(tmp_filename)
397
398     @staticmethod
399     def vpp_ipsec_sa_set_key(node, sa_id, crypto_key, integ_key):
400         """Update Security Association (SA) keys.
401
402         :param node: VPP node to update SA keys.
403         :param sa_id: SAD entry ID.
404         :param crypto_key: The encryption key string.
405         :param integ_key: The integrity key string.
406         :type node: dict
407         :type sa_id: int
408         :type crypto_key: str
409         :type integ_key: str
410         """
411         ckey = crypto_key.encode('hex')
412         ikey = integ_key.encode('hex')
413
414         out = VatExecutor.cmd_from_template(
415             node, 'ipsec/ipsec_sa_set_key.vat', json_param=False, sa_id=sa_id,
416             ckey=ckey, ikey=ikey)
417         VatJsonUtil.verify_vat_retval(
418             out[0],
419             err_msg='Update SA key failed on {0}'.format(node['host']))
420
421     @staticmethod
422     def vpp_ipsec_add_spd(node, spd_id):
423         """Create Security Policy Database on the VPP node.
424
425         :param node: VPP node to add SPD on.
426         :param spd_id: SPD ID.
427         :type node: dict
428         :type spd_id: int
429         """
430         out = VatExecutor.cmd_from_template(node, 'ipsec/ipsec_spd_add.vat',
431                                             spd_id=spd_id)
432         VatJsonUtil.verify_vat_retval(
433             out[0],
434             err_msg='Add SPD {0} failed on {1}'.format(spd_id, node['host']))
435
436     @staticmethod
437     def vpp_ipsec_spd_add_if(node, spd_id, interface):
438         """Add interface to the Security Policy Database.
439
440         :param node: VPP node.
441         :param spd_id: SPD ID to add interface on.
442         :param interface: Interface name or sw_if_index.
443         :type node: dict
444         :type spd_id: int
445         :type interface: str or int
446         """
447         sw_if_index = Topology.get_interface_sw_index(node, interface)\
448             if isinstance(interface, basestring) else interface
449
450         out = VatExecutor.cmd_from_template(node,
451                                             'ipsec/ipsec_interface_add_spd.vat',
452                                             spd_id=spd_id, sw_if_id=sw_if_index)
453         VatJsonUtil.verify_vat_retval(
454             out[0],
455             err_msg='Add interface {0} to SPD {1} failed on {2}'.format(
456                 interface, spd_id, node['host']))
457
458     @staticmethod
459     def vpp_ipsec_policy_add(node, spd_id, priority, action, inbound=True,
460                              sa_id=None, laddr_range=None, raddr_range=None,
461                              proto=None, lport_range=None, rport_range=None,
462                              is_ipv6=False):
463         """Create Security Policy Database entry on the VPP node.
464
465         :param node: VPP node to add SPD entry on.
466         :param spd_id: SPD ID to add entry on.
467         :param priority: SPD entry priority, higher number = higher priority.
468         :param action: Policy action.
469         :param inbound: If True policy is for inbound traffic, otherwise
470             outbound.
471         :param sa_id: SAD entry ID for protect action.
472         :param laddr_range: Policy selector local IPv4 or IPv6 address range in
473             format IP/prefix or IP/mask. If no mask is provided,
474             it's considered to be /32.
475         :param raddr_range: Policy selector remote IPv4 or IPv6 address range in
476             format IP/prefix or IP/mask. If no mask is provided,
477             it's considered to be /32.
478         :param proto: Policy selector next layer protocol number.
479         :param lport_range: Policy selector local TCP/UDP port range in format
480             <port_start>-<port_end>.
481         :param rport_range: Policy selector remote TCP/UDP port range in format
482             <port_start>-<port_end>.
483         :param is_ipv6: True in case of IPv6 policy when IPv6 address range is
484             not defined so it will default to address ::/0, otherwise False.
485         :type node: dict
486         :type spd_id: int
487         :type priority: int
488         :type action: PolicyAction
489         :type inbound: bool
490         :type sa_id: int
491         :type laddr_range: string
492         :type raddr_range: string
493         :type proto: int
494         :type lport_range: string
495         :type rport_range: string
496         :type is_ipv6: bool
497         """
498         direction = 'inbound' if inbound else 'outbound'
499
500         if laddr_range is None and is_ipv6:
501             laddr_range = '::/0'
502
503         if raddr_range is None and is_ipv6:
504             raddr_range = '::/0'
505
506         act_str = action.value
507         if PolicyAction.PROTECT == action and sa_id is not None:
508             act_str += ' sa {0}'.format(sa_id)
509
510         selector = ''
511         if laddr_range is not None:
512             net = ip_network(unicode(laddr_range), strict=False)
513             selector += 'local-ip-range {0} - {1} '.format(
514                 net.network_address, net.broadcast_address)
515         if raddr_range is not None:
516             net = ip_network(unicode(raddr_range), strict=False)
517             selector += 'remote-ip-range {0} - {1} '.format(
518                 net.network_address, net.broadcast_address)
519         if proto is not None:
520             selector += 'protocol {0} '.format(proto)
521         if lport_range is not None:
522             selector += 'local-port-range {0} '.format(lport_range)
523         if rport_range is not None:
524             selector += 'remote-port-range {0} '.format(rport_range)
525
526         out = VatExecutor.cmd_from_template(
527             node, 'ipsec/ipsec_policy_add.vat', json_param=False, spd_id=spd_id,
528             priority=priority, action=act_str, direction=direction,
529             selector=selector)
530         VatJsonUtil.verify_vat_retval(
531             out[0],
532             err_msg='Add IPsec policy ID {0} failed on {1}'.format(
533                 spd_id, node['host']))
534
535     @staticmethod
536     def vpp_ipsec_spd_add_entries(node, n_entries, spd_id, priority, inbound,
537                                   sa_id, raddr_ip, raddr_range):
538         """Create multiple Security Policy Database entries on the VPP node.
539
540         :param node: VPP node to add SPD entries on.
541         :param n_entries: Number of SPD entries to be added.
542         :param spd_id: SPD ID to add entries on.
543         :param priority: SPD entries priority, higher number = higher priority.
544         :param inbound: If True policy is for inbound traffic, otherwise
545             outbound.
546         :param sa_id: SAD entry ID for first entry. Each subsequent entry will
547             SAD entry ID incremented by 1.
548         :param raddr_ip: Policy selector remote IPv4 start address for the first
549             entry. Remote IPv4 end address will be calculated depending on
550             raddr_range parameter. Each subsequent entry will have start address
551             next after IPv4 end address of previous entry.
552         :param raddr_range: Mask specifying range of Policy selector Remote IPv4
553             addresses. Valid values are from 1 to 32.
554         :type node: dict
555         :type n_entries: int
556         :type spd_id: int
557         :type priority: int
558         :type inbound: bool
559         :type sa_id: int
560         :type raddr_ip: string
561         :type raddr_range: int
562         """
563         tmp_filename = '/tmp/ipsec_spd_{0}_add_del_entry.script'.format(sa_id)
564
565         direction = 'inbound' if inbound else 'outbound'
566         addr_incr = 1 << (32 - raddr_range)
567         addr_ip = int(ip_address(unicode(raddr_ip)))
568         start_str = 'exec ipsec policy add spd {0} priority {1} {2} ' \
569                     'action protect sa'.format(spd_id, priority, direction)
570         with open(tmp_filename, 'w') as tmp_file:
571             for i in range(0, n_entries):
572                 r_ip_s = ip_address(addr_ip + addr_incr * i)
573                 r_ip_e = ip_address(addr_ip + addr_incr * (i+1) - 1)
574                 buf_str = '{0} {1} remote-ip-range {2} - {3}\n'.format(
575                     start_str, sa_id+i, r_ip_s, r_ip_e)
576                 tmp_file.write(buf_str)
577         vat = VatExecutor()
578         vat.execute_script(tmp_filename, node, timeout=300, json_out=False,
579                            copy_on_execute=True)
580         os.remove(tmp_filename)
581
582     @staticmethod
583     def vpp_ipsec_create_tunnel_interfaces(node1, node2, if1_ip_addr,
584                                            if2_ip_addr, if1_key, if2_key,
585                                            n_tunnels, crypto_alg, crypto_key,
586                                            integ_alg, integ_key, raddr_ip1,
587                                            raddr_ip2, raddr_range):
588         """Create multiple IPsec tunnel interfaces between two VPP nodes.
589
590         :param node1: VPP node 1 to create tunnel interfaces.
591         :param node2: VPP node 2 to create tunnel interfaces.
592         :param if1_ip_addr: VPP node 1 interface IP4 address.
593         :param if2_ip_addr: VPP node 2 interface IP4 address.
594         :param if1_key: VPP node 1 interface key from topology file.
595         :param if2_key: VPP node 2 interface key from topology file.
596         :param n_tunnels: Number of tunnell interfaces to create.
597         :param crypto_alg: The encryption algorithm name.
598         :param crypto_key: The encryption key string.
599         :param integ_alg: The integrity algorithm name.
600         :param integ_key: The integrity key string.
601         :param raddr_ip1: Policy selector remote IPv4 start address for the
602             first tunnel in direction node1->node2.
603         :param raddr_ip2: Policy selector remote IPv4 start address for the
604             first tunnel in direction node2->node1.
605         :param raddr_range: Mask specifying range of Policy selector Remote IPv4
606             addresses. Valid values are from 1 to 32.
607         :type node1: dict
608         :type node2: dict
609         :type if1_ip_addr: str
610         :type if2_ip_addr: str
611         :type if1_key: str
612         :type if2_key: str
613         :type n_tunnels: int
614         :type crypto_alg: CryptoAlg
615         :type crypto_key: str
616         :type integ_alg: IntegAlg
617         :type integ_key: str
618         :type raddr_ip1: string
619         :type raddr_ip2: string
620         :type raddr_range: int
621         """
622         spi_1 = 10000
623         spi_2 = 20000
624
625         raddr_ip1_i = int(ip_address(unicode(raddr_ip1)))
626         raddr_ip2_i = int(ip_address(unicode(raddr_ip2)))
627         addr_incr = 1 << (32 - raddr_range)
628
629         tmp_fn1 = '/tmp/ipsec_create_tunnel_dut1.config'
630         tmp_fn2 = '/tmp/ipsec_create_tunnel_dut2.config'
631
632         ckey = crypto_key.encode('hex')
633         ikey = integ_key.encode('hex')
634
635         vat = VatExecutor()
636         with open(tmp_fn1, 'w') as tmp_f1, open(tmp_fn2, 'w') as tmp_f2:
637             for i in range(0, n_tunnels):
638                 integ = ''
639                 if not crypto_alg.alg_name.startswith('aes-gcm-'):
640                     integ = 'integ_alg {integ_alg} '\
641                             'local_integ_key {local_integ_key} '\
642                             'remote_integ_key {remote_integ_key} '\
643                             .format(integ_alg=integ_alg.alg_name,
644                                     local_integ_key=ikey,
645                                     remote_integ_key=ikey)
646                 dut1_tunnel = 'ipsec_tunnel_if_add_del '\
647                               'local_spi {local_spi} '\
648                               'remote_spi {remote_spi} '\
649                               'crypto_alg {crypto_alg} '\
650                               'local_crypto_key {local_crypto_key} '\
651                               'remote_crypto_key {remote_crypto_key} '\
652                               '{integ} '\
653                               'local_ip {local_ip} '\
654                               'remote_ip {remote_ip}\n'\
655                               .format(local_spi=spi_1+i,
656                                       remote_spi=spi_2+i,
657                                       crypto_alg=crypto_alg.alg_name,
658                                       local_crypto_key=ckey,
659                                       remote_crypto_key=ckey,
660                                       integ=integ,
661                                       local_ip=if1_ip_addr,
662                                       remote_ip=if2_ip_addr)
663                 dut2_tunnel = 'ipsec_tunnel_if_add_del '\
664                               'local_spi {local_spi} '\
665                               'remote_spi {remote_spi} '\
666                               'crypto_alg {crypto_alg} '\
667                               'local_crypto_key {local_crypto_key} '\
668                               'remote_crypto_key {remote_crypto_key} '\
669                               '{integ} '\
670                               'local_ip {local_ip} '\
671                               'remote_ip {remote_ip}\n'\
672                               .format(local_spi=spi_2+i,
673                                       remote_spi=spi_1+i,
674                                       crypto_alg=crypto_alg.alg_name,
675                                       local_crypto_key=ckey,
676                                       remote_crypto_key=ckey,
677                                       integ=integ,
678                                       local_ip=if2_ip_addr,
679                                       remote_ip=if1_ip_addr)
680                 tmp_f1.write(dut1_tunnel)
681                 tmp_f2.write(dut2_tunnel)
682         vat.execute_script(tmp_fn1, node1, timeout=300, json_out=False,
683                            copy_on_execute=True)
684         vat.execute_script(tmp_fn2, node2, timeout=300, json_out=False,
685                            copy_on_execute=True)
686         os.remove(tmp_fn1)
687         os.remove(tmp_fn2)
688
689         with open(tmp_fn1, 'w') as tmp_f1, open(tmp_fn2, 'w') as tmp_f2:
690             for i in range(0, n_tunnels):
691                 raddr_ip1 = ip_address(raddr_ip1_i + addr_incr*i)
692                 raddr_ip2 = ip_address(raddr_ip2_i + addr_incr*i)
693                 dut1_if = Topology.get_interface_name(node1, if1_key)
694                 dut1 = 'exec ip route add {raddr}/{mask} via {addr} ipsec{i}\n'\
695                        'exec set interface unnumbered ipsec{i} use {uifc}\n'\
696                        'exec set interface state ipsec{i} up\n'\
697                        .format(raddr=raddr_ip2, mask=raddr_range,
698                                addr=if2_ip_addr, i=i, uifc=dut1_if)
699                 dut2_if = Topology.get_interface_name(node2, if2_key)
700                 dut2 = 'exec ip route add {raddr}/{mask} via {addr} ipsec{i}\n'\
701                        'exec set interface unnumbered ipsec{i} use {uifc}\n'\
702                        'exec set interface state ipsec{i} up\n'\
703                        .format(raddr=raddr_ip1, mask=raddr_range,
704                                addr=if1_ip_addr, i=i, uifc=dut2_if)
705                 tmp_f1.write(dut1)
706                 tmp_f2.write(dut2)
707
708         vat.execute_script(tmp_fn1, node1, timeout=300, json_out=False,
709                            copy_on_execute=True)
710         vat.execute_script(tmp_fn2, node2, timeout=300, json_out=False,
711                            copy_on_execute=True)
712         os.remove(tmp_fn1)
713         os.remove(tmp_fn2)
714
715     @staticmethod
716     def vpp_ipsec_add_multiple_tunnels(node1, node2, interface1, interface2,
717                                        n_tunnels, crypto_alg, crypto_key,
718                                        integ_alg, integ_key, tunnel_ip1,
719                                        tunnel_ip2, raddr_ip1, raddr_ip2,
720                                        raddr_range):
721         """Create multiple IPsec tunnels between two VPP nodes.
722
723         :param node1: VPP node 1 to create tunnels.
724         :param node2: VPP node 2 to create tunnels.
725         :param interface1: Interface name or sw_if_index on node 1.
726         :param interface2: Interface name or sw_if_index on node 2.
727         :param n_tunnels: Number of tunnels to create.
728         :param crypto_alg: The encryption algorithm name.
729         :param crypto_key: The encryption key string.
730         :param integ_alg: The integrity algorithm name.
731         :param integ_key: The integrity key string.
732         :param tunnel_ip1: Tunnel node1 IPv4 address.
733         :param tunnel_ip2: Tunnel node2 IPv4 address.
734         :param raddr_ip1: Policy selector remote IPv4 start address for the
735             first tunnel in direction node1->node2.
736         :param raddr_ip2: Policy selector remote IPv4 start address for the
737             first tunnel in direction node2->node1.
738         :param raddr_range: Mask specifying range of Policy selector Remote IPv4
739             addresses. Valid values are from 1 to 32.
740         :type node1: dict
741         :type node2: dict
742         :type interface1: str or int
743         :type interface2: str or int
744         :type n_tunnels: int
745         :type crypto_alg: CryptoAlg
746         :type crypto_key: str
747         :type integ_alg: str
748         :type integ_key: str
749         :type tunnel_ip1: str
750         :type tunnel_ip2: str
751         :type raddr_ip1: string
752         :type raddr_ip2: string
753         :type raddr_range: int
754         """
755         spd_id = 1
756         p_hi = 100
757         p_lo = 10
758         sa_id_1 = 10000
759         sa_id_2 = 20000
760         spi_1 = 30000
761         spi_2 = 40000
762         proto = 50
763
764         IPsecUtil.vpp_ipsec_add_spd(node1, spd_id)
765         IPsecUtil.vpp_ipsec_spd_add_if(node1, spd_id, interface1)
766         IPsecUtil.vpp_ipsec_policy_add(node1, spd_id, p_hi, PolicyAction.BYPASS,
767                                        inbound=False, proto=proto)
768         IPsecUtil.vpp_ipsec_policy_add(node1, spd_id, p_hi, PolicyAction.BYPASS,
769                                        inbound=True, proto=proto)
770
771         IPsecUtil.vpp_ipsec_add_spd(node2, spd_id)
772         IPsecUtil.vpp_ipsec_spd_add_if(node2, spd_id, interface2)
773         IPsecUtil.vpp_ipsec_policy_add(node2, spd_id, p_hi, PolicyAction.BYPASS,
774                                        inbound=False, proto=proto)
775         IPsecUtil.vpp_ipsec_policy_add(node2, spd_id, p_hi, PolicyAction.BYPASS,
776                                        inbound=True, proto=proto)
777
778         IPsecUtil.vpp_ipsec_add_sad_entries(node1, n_tunnels, sa_id_1, spi_1,
779                                             crypto_alg, crypto_key, integ_alg,
780                                             integ_key, tunnel_ip1, tunnel_ip2)
781
782         IPsecUtil.vpp_ipsec_spd_add_entries(node1, n_tunnels, spd_id, p_lo,
783                                             False, sa_id_1, raddr_ip2,
784                                             raddr_range)
785
786         IPsecUtil.vpp_ipsec_add_sad_entries(node2, n_tunnels, sa_id_1, spi_1,
787                                             crypto_alg, crypto_key, integ_alg,
788                                             integ_key, tunnel_ip1, tunnel_ip2)
789
790         IPsecUtil.vpp_ipsec_spd_add_entries(node2, n_tunnels, spd_id, p_lo,
791                                             True, sa_id_1, raddr_ip2,
792                                             raddr_range)
793
794         IPsecUtil.vpp_ipsec_add_sad_entries(node2, n_tunnels, sa_id_2, spi_2,
795                                             crypto_alg, crypto_key, integ_alg,
796                                             integ_key, tunnel_ip2, tunnel_ip1)
797
798         IPsecUtil.vpp_ipsec_spd_add_entries(node2, n_tunnels, spd_id, p_lo,
799                                             False, sa_id_2, raddr_ip1,
800                                             raddr_range)
801
802         IPsecUtil.vpp_ipsec_add_sad_entries(node1, n_tunnels, sa_id_2, spi_2,
803                                             crypto_alg, crypto_key, integ_alg,
804                                             integ_key, tunnel_ip2, tunnel_ip1)
805
806         IPsecUtil.vpp_ipsec_spd_add_entries(node1, n_tunnels, spd_id, p_lo,
807                                             True, sa_id_2, raddr_ip1,
808                                             raddr_range)
809
810     @staticmethod
811     def vpp_ipsec_show(node):
812         """Run "show ipsec" debug CLI command.
813
814         :param node: Node to run command on.
815         :type node: dict
816         """
817         VatExecutor().execute_script('ipsec/ipsec_show.vat', node,
818                                      json_out=False)

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.