-
Notifications
You must be signed in to change notification settings - Fork 347
/
Copy pathec2_security_group.py
1808 lines (1635 loc) · 69.6 KB
/
ec2_security_group.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright: Contributors to the Ansible project
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
DOCUMENTATION = r"""
---
module: ec2_security_group
version_added: 1.0.0
author:
- "Andrew de Quincey (@adq)"
- "Razique Mahroua (@Razique)"
short_description: Maintain an EC2 security group
description:
- Maintains EC2 security groups.
options:
name:
description:
- Name of the security group.
- One of and only one of O(name) or O(group_id) is required.
- Required if O(state=present).
required: false
type: str
group_id:
description:
- Id of group to delete (works only with absent).
- One of and only one of O(name) or O(group_id) is required.
required: false
type: str
description:
description:
- Description of the security group.
- Required when O(state) is V(present).
required: false
type: str
vpc_id:
description:
- ID of the VPC to create the group in.
required: false
type: str
rules:
description:
- List of firewall inbound rules to enforce in this group (see example). If none are supplied,
no inbound rules will be enabled. Rules list may include its own name in O(rules.group_name).
This allows idempotent loopback additions (e.g. allow group to access itself).
required: false
type: list
elements: dict
suboptions:
cidr_ip:
type: list
elements: raw
description:
- The IPv4 CIDR range traffic is coming from.
- You can specify only one of O(rules.cidr_ip), O(rules.cidr_ipv6), O(rules.ip_prefix), O(rules.group_id)
and I(group_name).
- Support for passing nested lists of strings to O(rules.cidr_ip) has been deprecated and will
be removed in a release after 2024-12-01.
cidr_ipv6:
type: list
elements: raw
description:
- The IPv6 CIDR range traffic is coming from.
- You can specify only one of O(rules.cidr_ip), O(rules.cidr_ipv6), O(rules.ip_prefix), O(rules.group_id)
and I(rules.group_name).
- Support for passing nested lists of strings to O(rules.cidr_ipv6) has been deprecated and will
be removed in a release after 2024-12-01.
ip_prefix:
type: list
elements: str
description:
- The IP Prefix U(https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-prefix-lists.html)
that traffic is coming from.
- You can specify only one of O(rules.cidr_ip), O(rules.cidr_ipv6), O(rules.ip_prefix), O(rules.group_id)
and O(rules.group_name).
group_id:
type: list
elements: str
description:
- The ID of the Security Group that traffic is coming from.
- You can specify only one of O(rules.cidr_ip), O(rules.cidr_ipv6), O(rules.ip_prefix), O(rules.group_id)
and O(rules.group_name).
group_name:
type: list
elements: str
description:
- Name of the Security Group that traffic is coming from.
- If the Security Group doesn't exist a new Security Group will be
created with O(rules.group_desc) as the description.
- O(rules.group_name) can accept values of type str and list.
- You can specify only one of O(rules.cidr_ip), O(rules.cidr_ipv6), O(rules.ip_prefix), O(rules.group_id)
and O(rules.group_name).
group_desc:
type: str
description:
- If the O(rules.group_name) is set and the Security Group doesn't exist a new Security Group will be
created with O(rules.group_desc) as the description.
proto:
type: str
description:
- The IP protocol name (V(tcp), V(udp), V(icmp), V(icmpv6)) or
number (U(https://en.wikipedia.org/wiki/List_of_IP_protocol_numbers)).
default: tcp
from_port:
type: int
description:
- The start of the range of ports that traffic is going to.
- A value can be between V(0) to V(65535).
- When O(rules.proto=icmp) a value of V(-1) indicates all ports.
- Mutually exclusive with O(rules.icmp_code), O(rules.icmp_type) and O(rules.ports).
to_port:
type: int
description:
- The end of the range of ports that traffic is going to.
- A value can be between V(0) to V(65535).
- When O(rules.proto=icmp) a value of V(-1) indicates all ports.
- Mutually exclusive with O(rules.icmp_code), O(rules.icmp_type) and O(rules.ports).
ports:
type: list
elements: str
description:
- A list of ports that traffic is going to.
- Elements of the list can be a single port (for example V(8080)), or a range of ports
specified as V(<START>-<END>), (for example V(1011-1023)).
- Mutually exclusive with O(rules.icmp_code), O(rules.icmp_type), O(rules.from_port) and O(rules.to_port).
icmp_type:
version_added: 3.3.0
type: int
description:
- The ICMP type of the packet.
- A value of V(-1) indicates all ICMP types.
- Requires O(rules.proto=icmp) or O(rules.proto=icmpv6).
- Mutually exclusive withot O(rules.ports), O(rules.from_port) and O(rules.to_port).
icmp_code:
version_added: 3.3.0
type: int
description:
- The ICMP code of the packet.
- A value of V(-1) indicates all ICMP codes.
- Requires O(rules.proto=icmp) or O(rules.proto=icmpv6).
- Mutually exclusive with O(rules.ports), O(rules.from_port) and O(rules.to_port).
rule_desc:
type: str
description: A description for the rule.
rules_egress:
description:
- List of firewall outbound rules to enforce in this group (see example). If none are supplied,
a default all-out rule is assumed. If an empty list is supplied, no outbound rules will be enabled.
required: false
type: list
elements: dict
aliases: ['egress_rules']
suboptions:
cidr_ip:
type: list
elements: raw
description:
- The IPv4 CIDR range traffic is going to.
- You can specify only one of O(rules_egress.cidr_ip), O(rules_egress.cidr_ipv6), O(rules_egress.ip_prefix), O(rules_egress.group_id)
and I(rules_egress.group_name).
- Support for passing nested lists of strings to O(rules_egress.cidr_ip) has been deprecated and will
be removed in a release after 2024-12-01.
cidr_ipv6:
type: list
elements: raw
description:
- The IPv6 CIDR range traffic is going to.
- You can specify only one of O(rules_egress.cidr_ip), O(rules_egress.cidr_ipv6), O(rules_egress.ip_prefix), O(rules_egress.group_id)
and O(rules_egress.group_name).
- Support for passing nested lists of strings to O(rules_egress.cidr_ipv6) has been deprecated and will
be removed in a release after 2024-12-01.
ip_prefix:
type: list
elements: str
description:
- The IP Prefix U(https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-prefix-lists.html)
that traffic is going to.
- You can specify only one of O(rules_egress.cidr_ip), O(rules_egress.cidr_ipv6), O(rules_egress.ip_prefix), O(rules_egress.group_id)
and O(rules_egress.group_name).
group_id:
type: list
elements: str
description:
- The ID of the Security Group that traffic is going to.
- You can specify only one of O(rules_egress.cidr_ip), O(rules_egress.cidr_ipv6), O(rules_egress.ip_prefix), O(rules_egress.group_id)
and O(rules_egress.group_name).
group_name:
type: list
elements: str
description:
- Name of the Security Group that traffic is going to.
- If the Security Group doesn't exist a new Security Group will be
created with O(rules_egress.group_desc) as the description.
- You can specify only one of O(rules_egress.cidr_ip), O(rules_egress.cidr_ipv6), O(rules_egress.ip_prefix), O(rules_egress.group_id)
and O(rules_egress.group_name).
group_desc:
type: str
description:
- If the O(rules_egress.group_name) is set and the Security Group doesn't exist a new Security Group will be
created with O(rules_egress.group_desc) as the description.
proto:
type: str
description:
- The IP protocol name (V(tcp), V(udp), V(icmp), V(icmpv6)) or
number (U(https://en.wikipedia.org/wiki/List_of_IP_protocol_numbers)).
default: 'tcp'
from_port:
type: int
description:
- The start of the range of ports that traffic is going to.
- A value can be between V(0) to V(65535).
- When O(rules_egress.proto=icmp) a value of V(-1) indicates all ports.
- Mutually exclusive with O(rules_egress.icmp_code), O(rules_egress.icmp_type) and O(rules_egress.ports).
to_port:
type: int
description:
- The end of the range of ports that traffic is going to.
- A value can be between C(0) to C(65535).
- When O(rules_egress.proto=icmp) a value of V(-1) indicates all ports.
- Mutually exclusive with O(rules_egress.icmp_code), O(rules_egress.icmp_type) and O(rules_egress.ports).
ports:
type: list
elements: str
description:
- A list of ports that traffic is going to.
- Elements of the list can be a single port (for example V(8080)), or a range of ports
specified as V(<START>-<END>), (for example V(1011-1023)).
- Mutually exclusive with O(rules_egress.icmp_code), O(rules_egress.icmp_type), O(rules_egress.from_port) and O(rules_egress.to_port).
icmp_type:
version_added: 3.3.0
type: int
description:
- The ICMP type of the packet.
- A value of CV(-1) indicates all ICMP types.
- Requires O(rules_egress.proto=icmp) or O(rules_egress.proto=icmpv6).
- Mutually exclusive with O(rules_egress.ports), O(rules_egress.from_port) and O(rules_egress.to_port).
icmp_code:
version_added: 3.3.0
type: int
description:
- The ICMP code of the packet.
- A value of V(-1) indicates all ICMP codes.
- Requires O(rules_egress.proto=icmp) or O(rules_egress.proto=icmpv6).
- Mutually exclusive with O(rules_egress.ports), O(rules_egress.from_port) and O(rules_egress.to_port).
rule_desc:
type: str
description: A description for the rule.
state:
description:
- Create or delete a security group.
required: false
default: 'present'
choices: [ "present", "absent" ]
aliases: []
type: str
purge_rules:
description:
- Purge existing rules on security group that are not found in rules.
required: false
default: 'true'
aliases: []
type: bool
purge_rules_egress:
description:
- Purge existing rules_egress on security group that are not found in rules_egress.
required: false
default: 'true'
aliases: ['purge_egress_rules']
type: bool
extends_documentation_fragment:
- amazon.aws.common.modules
- amazon.aws.region.modules
- amazon.aws.tags
- amazon.aws.boto3
notes:
- If a rule declares a group_name and that group doesn't exist, it will be
automatically created. In that case, group_desc should be provided as well.
The module will refuse to create a depended-on group without a description.
- Prior to release 5.0.0 this module was called M(amazon.aws.ec2_group_info). The usage did not
change.
"""
EXAMPLES = r"""
# Note: These examples do not set authentication details, see the AWS Guide for details.
- name: example using security group rule descriptions
amazon.aws.ec2_security_group:
name: "{{ name }}"
description: sg with rule descriptions
vpc_id: vpc-xxxxxxxx
rules:
- proto: tcp
ports:
- 80
cidr_ip: 0.0.0.0/0
rule_desc: allow all on port 80
- name: example using ICMP types and codes
amazon.aws.ec2_security_group:
name: "{{ name }}"
description: sg for ICMP
vpc_id: vpc-xxxxxxxx
rules:
- proto: icmp
icmp_type: 3
icmp_code: 1
cidr_ip: 0.0.0.0/0
- name: example ec2 group
amazon.aws.ec2_security_group:
name: example
description: an example EC2 group
vpc_id: 12345
rules:
- proto: tcp
from_port: 80
to_port: 80
cidr_ip: 0.0.0.0/0
- proto: tcp
from_port: 22
to_port: 22
cidr_ip: 10.0.0.0/8
- proto: tcp
from_port: 443
to_port: 443
# this should only be needed for EC2 Classic security group rules
# because in a VPC an ELB will use a user-account security group
group_id: amazon-elb/sg-87654321/amazon-elb-sg
- proto: tcp
from_port: 3306
to_port: 3306
group_id: 123456789012/sg-87654321/exact-name-of-sg
- proto: udp
from_port: 10050
to_port: 10050
cidr_ip: 10.0.0.0/8
- proto: udp
from_port: 10051
to_port: 10051
group_id: sg-12345678
- proto: icmp
from_port: 8 # icmp type, -1 = any type
to_port: -1 # icmp subtype, -1 = any subtype
cidr_ip: 10.0.0.0/8
- proto: all
# the containing group name may be specified here
group_name: example
- proto: all
# in the 'proto' attribute, if you specify -1 (only supported when I(proto=icmp)), all, or a protocol number
# other than tcp, udp, icmp, or 58 (ICMPv6), traffic on all ports is allowed, regardless of any ports that
# you specify.
from_port: 10050 # this value is ignored
to_port: 10050 # this value is ignored
cidr_ip: 10.0.0.0/8
rules_egress:
- proto: tcp
from_port: 80
to_port: 80
cidr_ip: 0.0.0.0/0
cidr_ipv6: 64:ff9b::/96
group_name: example-other
# description to use if example-other needs to be created
group_desc: other example EC2 group
- name: example2 ec2 group
amazon.aws.ec2_security_group:
name: example2
description: an example2 EC2 group
vpc_id: 12345
rules:
# 'ports' rule keyword was introduced in version 2.4. It accepts a single
# port value or a list of values including ranges (from_port-to_port).
- proto: tcp
ports: 22
group_name: example-vpn
- proto: tcp
ports:
- 80
- 443
- 8080-8099
cidr_ip: 0.0.0.0/0
# Rule sources list support was added in version 2.4. This allows to
# define multiple sources per source type as well as multiple source types per rule.
- proto: tcp
ports:
- 6379
- 26379
group_name:
- example-vpn
- example-redis
- proto: tcp
ports: 5665
group_name: example-vpn
cidr_ip:
- 172.16.1.0/24
- 172.16.17.0/24
cidr_ipv6:
- 2607:F8B0::/32
- 64:ff9b::/96
group_id:
- sg-edcd9784
diff: true
- name: "Delete group by its id"
amazon.aws.ec2_security_group:
group_id: sg-33b4ee5b
state: absent
"""
RETURN = r"""
description:
description: Description of security group.
sample: My Security Group
type: str
returned: on create/update
group_id:
description: Security group id.
sample: sg-abcd1234
type: str
returned: on create/update
group_name:
description: Security group name.
sample: My Security Group
type: str
returned: on create/update
ip_permissions:
description: The inbound rules associated with the security group.
returned: always
type: list
elements: dict
contains:
from_port:
description: If the protocol is TCP or UDP, this is the start of the port range.
type: int
sample: 80
ip_protocol:
description: The IP protocol name or number.
returned: always
type: str
ip_ranges:
description: The IPv4 ranges.
returned: always
type: list
elements: dict
contains:
cidr_ip:
description: The IPv4 CIDR range.
returned: always
type: str
ipv6_ranges:
description: The IPv6 ranges.
returned: always
type: list
elements: dict
contains:
cidr_ipv6:
description: The IPv6 CIDR range.
returned: always
type: str
prefix_list_ids:
description: The prefix list IDs.
returned: always
type: list
elements: dict
contains:
prefix_list_id:
description: The ID of the prefix.
returned: always
type: str
to_group:
description: If the protocol is TCP or UDP, this is the end of the port range.
type: int
sample: 80
user_id_group_pairs:
description: The security group and AWS account ID pairs.
returned: always
type: list
elements: dict
contains:
group_id:
description: The security group ID of the pair.
returned: always
type: str
user_id:
description: The user ID of the pair.
returned: always
type: str
ip_permissions_egress:
description: The outbound rules associated with the security group.
returned: always
type: list
elements: dict
contains:
ip_protocol:
description: The IP protocol name or number.
returned: always
type: str
ip_ranges:
description: The IPv4 ranges.
returned: always
type: list
elements: dict
contains:
cidr_ip:
description: The IPv4 CIDR range.
returned: always
type: str
ipv6_ranges:
description: The IPv6 ranges.
returned: always
type: list
elements: dict
contains:
cidr_ipv6:
description: The IPv6 CIDR range.
returned: always
type: str
prefix_list_ids:
description: The prefix list IDs.
returned: always
type: list
elements: dict
contains:
prefix_list_id:
description: The ID of the prefix.
returned: always
type: str
user_id_group_pairs:
description: The security group and AWS account ID pairs.
returned: always
type: list
elements: dict
contains:
group_id:
description: The security group ID of the pair.
returned: always
type: str
user_id:
description: The user ID of the pair.
returned: always
type: str
owner_id:
description: AWS Account ID of the security group.
sample: 123456789012
type: int
returned: on create/update
tags:
description: Tags associated with the security group.
sample:
Name: My Security Group
Purpose: protecting stuff
type: dict
returned: on create/update
vpc_id:
description: ID of VPC to which the security group belongs.
sample: vpc-abcd1234
type: str
returned: on create/update
"""
import itertools
import json
import re
from collections import namedtuple
from copy import deepcopy
from ipaddress import ip_network
from time import sleep
from typing import Any
from typing import Dict
from typing import List
from typing import Optional
from typing import Tuple
from ansible.module_utils._text import to_text
from ansible.module_utils.common.dict_transformations import camel_dict_to_snake_dict
from ansible.module_utils.common.network import to_ipv6_subnet
from ansible.module_utils.common.network import to_subnet
from ansible.module_utils.six import string_types
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import AnsibleEC2Error
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import authorize_security_group_egress
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import authorize_security_group_ingress
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import create_security_group
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import delete_security_group
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import describe_security_groups
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import ensure_ec2_tags
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import revoke_security_group_egress
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import revoke_security_group_ingress
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import update_security_group_rule_descriptions_egress
from ansible_collections.amazon.aws.plugins.module_utils.ec2 import update_security_group_rule_descriptions_ingress
from ansible_collections.amazon.aws.plugins.module_utils.exceptions import AnsibleAWSError
from ansible_collections.amazon.aws.plugins.module_utils.exceptions import is_ansible_aws_error_code
from ansible_collections.amazon.aws.plugins.module_utils.iam import get_aws_account_id
from ansible_collections.amazon.aws.plugins.module_utils.modules import AnsibleAWSModule
from ansible_collections.amazon.aws.plugins.module_utils.tagging import boto3_tag_list_to_ansible_dict
from ansible_collections.amazon.aws.plugins.module_utils.tagging import boto3_tag_specifications
from ansible_collections.amazon.aws.plugins.module_utils.tagging import compare_aws_tags
from ansible_collections.amazon.aws.plugins.module_utils.transformation import ansible_dict_to_boto3_filter_list
from ansible_collections.amazon.aws.plugins.module_utils.transformation import scrub_none_parameters
from ansible_collections.amazon.aws.plugins.module_utils.waiters import wait_for_resource_state
Rule = namedtuple("Rule", ["port_range", "protocol", "target", "target_type", "description"])
TARGET_TYPES_ALL = {"ipv4", "ipv6", "group", "ip_prefix"}
SOURCE_TYPES_ALL = {"cidr_ip", "cidr_ipv6", "group_id", "group_name", "ip_prefix"}
PORT_TYPES_ALL = {"from_port", "to_port", "ports", "icmp_type", "icmp_code"}
current_account_id = None
class SecurityGroupError(Exception):
def __init__(self, msg, e=None, **kwargs):
super().__init__(msg)
self.message = msg
self.exception = e
self.kwargs = kwargs
# Simple helper to perform the module.fail_... call once we have module available to us
def fail(self, module):
if self.exception:
if isinstance(self.exception, AnsibleEC2Error):
module.fail_json_aws_error(self.exception)
module.fail_json_aws(self.exception, msg=self.message, **self.kwargs)
module.fail_json(msg=self.message, **self.kwargs)
def rule_cmp(a, b):
"""Compare rules without descriptions"""
for prop in ["port_range", "protocol", "target", "target_type"]:
if prop == "port_range" and to_text(a.protocol) == to_text(b.protocol):
# equal protocols can interchange `(-1, -1)` and `(None, None)`
if a.port_range in ((None, None), (-1, -1)) and b.port_range in ((None, None), (-1, -1)):
continue
if getattr(a, prop) != getattr(b, prop):
return False
elif getattr(a, prop) != getattr(b, prop):
return False
return True
def rules_to_permissions(rules):
return [to_permission(rule) for rule in rules]
def to_permission(rule):
# take a Rule, output the serialized grant
perm = {
"IpProtocol": rule.protocol,
}
perm["FromPort"], perm["ToPort"] = rule.port_range
if rule.target_type == "ipv4":
perm["IpRanges"] = [
{
"CidrIp": rule.target,
}
]
if rule.description:
perm["IpRanges"][0]["Description"] = rule.description
elif rule.target_type == "ipv6":
perm["Ipv6Ranges"] = [
{
"CidrIpv6": rule.target,
}
]
if rule.description:
perm["Ipv6Ranges"][0]["Description"] = rule.description
elif rule.target_type == "group":
if isinstance(rule.target, tuple):
pair = {}
if rule.target[0]:
pair["UserId"] = rule.target[0]
# group_id/group_name are mutually exclusive - give group_id more precedence as it is more specific
if rule.target[1]:
pair["GroupId"] = rule.target[1]
elif rule.target[2]:
pair["GroupName"] = rule.target[2]
perm["UserIdGroupPairs"] = [pair]
else:
perm["UserIdGroupPairs"] = [{"GroupId": rule.target}]
if rule.description:
perm["UserIdGroupPairs"][0]["Description"] = rule.description
elif rule.target_type == "ip_prefix":
perm["PrefixListIds"] = [
{
"PrefixListId": rule.target,
}
]
if rule.description:
perm["PrefixListIds"][0]["Description"] = rule.description
elif rule.target_type not in TARGET_TYPES_ALL:
raise ValueError(f"Invalid target type for rule {rule}")
return fix_port_and_protocol(perm)
def rule_from_group_permission(perm):
"""
Returns a rule dict from an existing security group.
When using a security group as a target all 3 fields (OwnerId, GroupId, and
GroupName) need to exist in the target. This ensures consistency of the
values that will be compared to desired_ingress or desired_egress
in wait_for_rule_propagation().
GroupId is preferred as it is more specific except when targeting 'amazon-'
prefixed security groups (such as EC2 Classic ELBs).
"""
def ports_from_permission(p):
if "FromPort" not in p and "ToPort" not in p:
return (None, None)
return (int(perm["FromPort"]), int(perm["ToPort"]))
# outputs a rule tuple
for target_key, target_subkey, target_type in [
("IpRanges", "CidrIp", "ipv4"),
("Ipv6Ranges", "CidrIpv6", "ipv6"),
("PrefixListIds", "PrefixListId", "ip_prefix"),
]:
if target_key not in perm:
continue
for r in perm[target_key]:
# there may be several IP ranges here, which is ok
yield Rule(
ports_from_permission(perm),
to_text(perm["IpProtocol"]),
r[target_subkey],
target_type,
r.get("Description"),
)
if "UserIdGroupPairs" in perm and perm["UserIdGroupPairs"]:
for pair in perm["UserIdGroupPairs"]:
target = (
pair.get("UserId", current_account_id),
pair.get("GroupId", None),
None,
)
if pair.get("UserId", "").startswith("amazon-"):
# amazon-elb and amazon-prefix rules don't need
# group-id specified, so remove it when querying
# from permission
target = (
pair.get("UserId", None),
None,
pair.get("GroupName", None),
)
elif "VpcPeeringConnectionId" not in pair and pair["UserId"] != current_account_id:
# EC2-Classic cross-account
pass
elif "VpcPeeringConnectionId" in pair:
# EC2-VPC cross-account VPC peering
target = (
pair.get("UserId", None),
pair.get("GroupId", None),
None,
)
yield Rule(
ports_from_permission(perm), to_text(perm["IpProtocol"]), target, "group", pair.get("Description")
)
def deduplicate_rules_args(rules):
"""Returns unique rules"""
if rules is None:
return None
return list(dict(zip((json.dumps(r, sort_keys=True) for r in rules), rules)).values())
def validate_rule(rule):
icmp_type = rule.get("icmp_type", None)
icmp_code = rule.get("icmp_code", None)
proto = rule["proto"]
if (icmp_type is not None or icmp_code is not None) and ("icmp" not in proto):
raise SecurityGroupError(msg="Specify proto: icmp or icmpv6 when using icmp_type/icmp_code")
def _target_from_rule_with_group_id(rule, groups):
owner_id = current_account_id
FOREIGN_SECURITY_GROUP_REGEX = r"^([^/]+)/?(sg-\S+)?/(\S+)"
foreign_rule = re.match(FOREIGN_SECURITY_GROUP_REGEX, rule["group_id"])
if not foreign_rule:
return "group", (owner_id, rule["group_id"], None), False
# this is a foreign Security Group. Since you can't fetch it you must create an instance of it
# Matches on groups like amazon-elb/sg-5a9c116a/amazon-elb-sg, amazon-elb/amazon-elb-sg,
# and peer-VPC groups like 0987654321/sg-1234567890/example
owner_id, group_id, group_name = foreign_rule.groups()
group_instance = dict(UserId=owner_id, GroupId=group_id, GroupName=group_name)
groups[group_id] = group_instance
groups[group_name] = group_instance
if group_id and group_name:
if group_name.startswith("amazon-"):
# amazon-elb and amazon-prefix rules don't need group_id specified,
group_id = None
else:
# For cross-VPC references we'll use group_id as it is more specific
group_name = None
return "group", (owner_id, group_id, group_name), False
def _lookup_target_or_fail(client, group_name: str, vpc_id: Optional[str], msg: str) -> Optional[Dict[str, Any]]:
filters = {"group-name": group_name}
if vpc_id:
filters["vpc-id"] = vpc_id
filters = ansible_dict_to_boto3_filter_list(filters)
try:
found_group = describe_security_groups(client, Filters=filters)
if not found_group:
raise SecurityGroupError(msg=msg)
return found_group[0]
except AnsibleEC2Error as e:
raise SecurityGroupError(msg="Failed to get security group", e=e)
def _create_target_from_rule(
client, module: AnsibleAWSModule, rule: Dict[str, Any], vpc_id: str, tags: Dict[str, Any]
) -> Tuple[Optional[Dict[str, Any]], bool]:
# We can't create a group in check mode...
if module.check_mode:
return None, True
group_name = rule["group_name"]
changed = False
group = None
try:
group = _create_security_group_with_wait(client, module, group_name, rule["group_desc"], vpc_id, tags)
changed = True
except is_ansible_aws_error_code("InvalidGroup.Duplicate"):
# The group exists, but didn't show up in any of our previous describe-security-groups calls
# Try searching on a filter for the name, and allow a retry window for AWS to update
# the model on their end.
fail_msg = (
f"Could not create or use existing group '{group_name}' in rule {rule}. "
"Make sure the group exists and try using the group_id "
"instead of the name"
)
group = _lookup_target_or_fail(client, group_name, vpc_id, fail_msg)
changed = False
except AnsibleAWSError as e: # pylint: disable=duplicate-except
raise SecurityGroupError(msg=f"Failed to create security group '{group_name}' in rule {rule}", e=e)
return group, changed
def _target_from_rule_with_group_name(
client,
module: AnsibleAWSModule,
rule: Dict[str, Any],
name: str,
group: Dict[str, Any],
groups: Dict[str, Any],
vpc_id: str,
tags: Dict[str, Any],
) -> Tuple[str, bool]:
group_name = rule["group_name"]
if group_name == name:
# Simplest case, the rule references itself
group_id = group["GroupId"]
groups[group_id] = group
groups[group_name] = group
return group_id, False
# Already cached groups
if group_name in groups and group.get("VpcId") and groups[group_name].get("VpcId"):
# both are VPC groups, this is ok
group_id = groups[group_name]["GroupId"]
return group_id, False
if group_name in groups and not (group.get("VpcId") or groups[group_name].get("VpcId")):
# both are EC2 classic, this is ok
group_id = groups[group_name]["GroupId"]
return group_id, False
# if we got here, either the target group does not exist, or there
# is a mix of EC2 classic + VPC groups. Mixing of EC2 classic + VPC
# is bad, so we have to create a new SG because no compatible group
# exists
changed = False
# Without a group description we can't create a new group, try looking up the group, or fail
# with a descriptive error message
if not rule.get("group_desc", "").strip():
# retry describing the group
fail_msg = (
f"group '{group_name}' not found and would be automatically created by rule {rule} but "
"no description was provided"
)
created_group = _lookup_target_or_fail(client, group_name, vpc_id, fail_msg)
else:
created_group, changed = _create_target_from_rule(client, module, rule, vpc_id, tags)
group_id = None
if created_group:
group_id = created_group["GroupId"]
groups[group_id] = created_group
groups[group_name] = created_group
return group_id, changed
def get_target_from_rule(module, client, rule, name, group, groups, vpc_id, tags):
"""
Returns tuple of (target_type, target, group_created) after validating rule params.
rule: Dict describing a rule.
name: Name of the security group being managed.
groups: Dict of all available security groups.
AWS accepts an ip range or a security group as target of a rule. This
function validate the rule specification and return either a non-None
group_id or a non-None ip range.
When using a security group as a target all 3 fields (OwnerId, GroupId, and
GroupName) need to exist in the target. This ensures consistency of the
values that will be compared to current_rules (from current_ingress and
current_egress) in wait_for_rule_propagation().
"""
try:
if rule.get("group_id"):
return _target_from_rule_with_group_id(rule, groups)
if "group_name" in rule:
group_id, changed = _target_from_rule_with_group_name(
client, module, rule, name, group, groups, vpc_id, tags
)
return "group", (current_account_id, group_id, None), changed
if "cidr_ip" in rule:
return "ipv4", validate_ip(module, rule["cidr_ip"]), False
if "cidr_ipv6" in rule:
return "ipv6", validate_ip(module, rule["cidr_ipv6"]), False
if "ip_prefix" in rule:
return "ip_prefix", rule["ip_prefix"], False
except SecurityGroupError as e:
e.fail(module)
module.fail_json(msg="Could not match target for rule", failed_rule=rule)
def _strip_rule(rule):
"""
Returns a copy of the rule with the Target/Source and Port information
from a rule stripped out.
This can then be combined with the expanded information
"""
stripped_rule = deepcopy(rule)
# Get just the non-source/port info from the rule
[stripped_rule.pop(source_type, None) for source_type in SOURCE_TYPES_ALL]
[stripped_rule.pop(port_type, None) for port_type in PORT_TYPES_ALL]
return stripped_rule
def expand_rules(rules):
if rules is None:
return rules
expanded_rules = []
for rule in rules:
expanded_rules.extend(expand_rule(rule))
return expanded_rules
def expand_rule(rule):
rule = scrub_none_parameters(rule)
ports_list = expand_ports_from_rule(rule)
sources_list = expand_sources_from_rule(rule)
stripped_rule = _strip_rule(rule)
# expands out all possible combinations of ports and sources for the rule
# This results in a list of pairs of dictionaries...
ports_and_sources = itertools.product(ports_list, sources_list)
# Combines each pair of port/source dictionaries with rest of the info from the rule
return [{**stripped_rule, **port, **source} for (port, source) in ports_and_sources]
def expand_sources_from_rule(rule):
sources = []
for type_name in sorted(SOURCE_TYPES_ALL):
if rule.get(type_name) is not None:
sources.extend([{type_name: target} for target in rule.get(type_name)])
if not sources:
raise SecurityGroupError("Unable to find source/target information in rule", rule=rule)
return tuple(sources)
def expand_ports_from_rule(rule):
# While icmp_type/icmp_code could have been aliases, this wouldn't be obvious in the
# documentation
if rule.get("icmp_type") is not None:
return ({"from_port": rule.get("icmp_type"), "to_port": rule.get("icmp_code")},)
if rule.get("from_port") is not None or rule.get("to_port") is not None:
return ({"from_port": rule.get("from_port"), "to_port": rule.get("to_port")},)
if rule.get("ports") is not None:
ports = expand_ports_list(rule.get("ports"))
return tuple({"from_port": from_port, "to_port": to_port} for (from_port, to_port) in ports)