terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/security-group.js

@@ -0,0 +1,538 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityGroup = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/security-group.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const connections_1 = require("./connections");
+const peer_1 = require("./peer");
+const port_1 = require("./port");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+// import { allowAllOutboundLocal } from "./private/context-stub";
+const SECURITY_GROUP_SYMBOL = Symbol.for("terraconstructs/lib/aws/compute.SecurityGroup");
+const SECURITY_GROUP_DISABLE_INLINE_RULES_CONTEXT_KEY = "terraconstructs/aws/compute.securityGroupDisableInlineRules";
+/**
+ * A SecurityGroup that is not created in this template
+ */
+class SecurityGroupBase extends aws_construct_1.AwsConstructBase {
+    /**
+     * Return whether the indicated object is a security group
+     */
+    static isSecurityGroup(x) {
+        return SECURITY_GROUP_SYMBOL in x;
+    }
+    get securityGroupOutputs() {
+        return {
+            securityGroupId: this.securityGroupId,
+        };
+    }
+    get outputs() {
+        return this.securityGroupOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.canInlineRule = false;
+        this.connections = new connections_1.Connections({
+            securityGroups: [this],
+        });
+        this.peerAsTokenCount = 0;
+        Object.defineProperty(this, SECURITY_GROUP_SYMBOL, { value: true });
+    }
+    get uniqueId() {
+        return aws_stack_1.AwsStack.uniqueId(this.node);
+    }
+    addIngressRule(peer, connection, description, remoteRule) {
+        if (description === undefined) {
+            description = `from ${peer.uniqueId}:${connection}`;
+        }
+        const { scope, id } = this.determineRuleScope(peer, connection, "from", remoteRule);
+        // Skip duplicates
+        if (scope.node.tryFindChild(id) === undefined) {
+            new provider_aws_1.vpcSecurityGroupIngressRule.VpcSecurityGroupIngressRule(scope, id, {
+                securityGroupId: this.securityGroupId,
+                ...peer.toIngressRuleConfig(),
+                ...connection.toRuleJson(),
+                description,
+            });
+        }
+    }
+    addEgressRule(peer, connection, description, remoteRule) {
+        if (description === undefined) {
+            description = `to ${peer.uniqueId}:${connection}`;
+        }
+        const { scope, id } = this.determineRuleScope(peer, connection, "to", remoteRule);
+        // Skip duplicates
+        if (scope.node.tryFindChild(id) === undefined) {
+            new provider_aws_1.vpcSecurityGroupEgressRule.VpcSecurityGroupEgressRule(scope, id, {
+                securityGroupId: this.securityGroupId,
+                ...peer.toEgressRuleConfig(),
+                ...connection.toRuleJson(),
+                description,
+            });
+        }
+    }
+    toIngressRuleConfig() {
+        return this.toRuleConfig();
+    }
+    toEgressRuleConfig() {
+        return this.toRuleConfig();
+    }
+    // Terraform does not use different properties between ingress and egress rules
+    toRuleConfig() {
+        return { referencedSecurityGroupId: this.securityGroupId };
+    }
+    /**
+     * Determine where to parent a new ingress/egress rule
+     *
+     * A SecurityGroup rule is parented under the group it's related to, UNLESS
+     * we're in a cross-stack scenario with another Security Group. In that case,
+     * we respect the 'remoteRule' flag and will parent under the other security
+     * group.
+     *
+     * This is necessary to avoid cyclic dependencies between stacks, since both
+     * ingress and egress rules will reference both security groups, and a naive
+     * parenting will lead to the following situation:
+     *
+     *   ╔════════════════════╗         ╔════════════════════╗
+     *   ║  ┌───────────┐     ║         ║    ┌───────────┐   ║
+     *   ║  │  GroupA   │◀────╬─┐   ┌───╬───▶│  GroupB   │   ║
+     *   ║  └───────────┘     ║ │   │   ║    └───────────┘   ║
+     *   ║        ▲           ║ │   │   ║          ▲         ║
+     *   ║        │           ║ │   │   ║          │         ║
+     *   ║        │           ║ │   │   ║          │         ║
+     *   ║  ┌───────────┐     ║ └───┼───╬────┌───────────┐   ║
+     *   ║  │  EgressA  │─────╬─────┘   ║    │ IngressB  │   ║
+     *   ║  └───────────┘     ║         ║    └───────────┘   ║
+     *   ║                    ║         ║                    ║
+     *   ╚════════════════════╝         ╚════════════════════╝
+     *
+     * By having the ability to switch the parent, we avoid the cyclic reference by
+     * keeping all rules in a single stack.
+     *
+     * If this happens, we also have to change the construct ID, because
+     * otherwise we might have two objects with the same ID if we have
+     * multiple reversed security group relationships.
+     *
+     *   ╔═══════════════════════════════════╗
+     *   ║┌───────────┐                      ║
+     *   ║│  GroupB   │                      ║
+     *   ║└───────────┘                      ║
+     *   ║      ▲                            ║
+     *   ║      │              ┌───────────┐ ║
+     *   ║      ├────"from A"──│ IngressB  │ ║
+     *   ║      │              └───────────┘ ║
+     *   ║      │              ┌───────────┐ ║
+     *   ║      ├─────"to B"───│  EgressA  │ ║
+     *   ║      │              └───────────┘ ║
+     *   ║      │              ┌───────────┐ ║
+     *   ║      └─────"to B"───│  EgressC  │ ║  <-- oops
+     *   ║                     └───────────┘ ║
+     *   ╚═══════════════════════════════════╝
+     */
+    determineRuleScope(peer, connection, fromTo, remoteRule) {
+        if (remoteRule &&
+            SecurityGroupBase.isSecurityGroup(peer) &&
+            differentStacks(this, peer)) {
+            // Reversed
+            const reversedFromTo = fromTo === "from" ? "to" : "from";
+            return {
+                scope: peer,
+                id: `${this.uniqueId}:${connection} ${reversedFromTo}`,
+            };
+        }
+        else {
+            // Regular (do old ID escaping in order to not disturb existing deployments)
+            return {
+                scope: this,
+                id: `${fromTo} ${this.renderPeer(peer)}:${connection}`.replace("/", "_"),
+            };
+        }
+    }
+    renderPeer(peer) {
+        if (cdktf_1.Token.isUnresolved(peer.uniqueId)) {
+            // Need to return a unique value each time a peer
+            // is an unresolved token, else the duplicate skipper
+            // in `sg.addXxxRule` can detect unique rules as duplicates
+            return this.peerAsTokenCount++
+                ? `'{IndirectPeer${this.peerAsTokenCount}}'`
+                : "{IndirectPeer}";
+        }
+        else {
+            return peer.uniqueId;
+        }
+    }
+}
+function differentStacks(group1, group2) {
+    return aws_stack_1.AwsStack.of(group1) !== aws_stack_1.AwsStack.of(group2);
+}
+/**
+ * Creates an Amazon EC2 security group within a VPC.
+ *
+ * Security Groups act like a firewall with a set of rules, and are associated
+ * with any AWS resource that has or creates Elastic Network Interfaces (ENIs).
+ * A typical example of a resource that has a security group is an Instance (or
+ * Auto Scaling Group of instances)
+ *
+ * If you are defining new infrastructure in CDK, there is a good chance you
+ * won't have to interact with this class at all. Like IAM Roles, Security
+ * Groups need to exist to control access between AWS resources, but CDK will
+ * automatically generate and populate them with least-privilege permissions
+ * for you so you can concentrate on your business logic.
+ *
+ * All Constructs that require Security Groups will create one for you if you
+ * don't specify one at construction. After construction, you can selectively
+ * allow connections to and between constructs via--for example-- the `instance.connections`
+ * object. Think of it as "allowing connections to your instance", rather than
+ * "adding ingress rules a security group". See the [Allowing
+ * Connections](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-cdk-lib.aws_ec2-readme.html#allowing-connections)
+ * section in the library documentation for examples.
+ *
+ * Direct manipulation of the Security Group through `addIngressRule` and
+ * `addEgressRule` is possible, but mutation through the `.connections` object
+ * is recommended. If you peer two constructs with security groups this way,
+ * appropriate rules will be created in both.
+ *
+ * If you have an existing security group you want to use in your CDK application,
+ * you would import it like this:
+ *
+ * ```ts
+ * const securityGroup = compute.SecurityGroup.fromSecurityGroupId(this, 'SG', 'sg-12345', {
+ *   mutable: false
+ * });
+ * ```
+ */
+class SecurityGroup extends SecurityGroupBase {
+    /**
+     * Look up a security group by id.
+     */
+    static fromLookupById(scope, id, securityGroupId, allowAllOutbound) {
+        return this.fromLookupAttributes(scope, id, {
+            securityGroupId,
+            allowAllOutbound,
+        });
+    }
+    /**
+     * Look up a security group by name.
+     */
+    static fromLookupByName(scope, id, securityGroupName, vpc, allowAllOutbound) {
+        return this.fromLookupAttributes(scope, id, {
+            securityGroupName,
+            vpc,
+            allowAllOutbound,
+        });
+    }
+    /**
+     * Import an existing security group into this app.
+     *
+     * This method will assume that the Security Group has a rule in it which allows
+     * all outbound traffic, and so will not add egress rules to the imported Security
+     * Group (only ingress rules).
+     *
+     * If your existing Security Group needs to have egress rules added, pass the
+     * `allowAllOutbound: false` option on import.
+     */
+    static fromSecurityGroupId(scope, id, securityGroupId, options = {}) {
+        class MutableImport extends SecurityGroupBase {
+            constructor() {
+                super(...arguments);
+                this.securityGroupId = securityGroupId;
+                this.allowAllOutbound = options.allowAllOutbound ?? true;
+                this.allowAllIpv6Outbound = options.allowAllIpv6Outbound ?? false;
+            }
+            addEgressRule(peer, connection, description, remoteRule) {
+                // Only if allowAllOutbound has been disabled
+                if (options.allowAllOutbound === false) {
+                    super.addEgressRule(peer, connection, description, remoteRule);
+                }
+            }
+        }
+        class ImmutableImport extends SecurityGroupBase {
+            constructor() {
+                super(...arguments);
+                this.securityGroupId = securityGroupId;
+                this.allowAllOutbound = options.allowAllOutbound ?? true;
+                this.allowAllIpv6Outbound = options.allowAllIpv6Outbound ?? false;
+            }
+            addEgressRule(_peer, _connection, _description, _remoteRule) {
+                // do nothing
+            }
+            addIngressRule(_peer, _connection, _description, _remoteRule) {
+                // do nothing
+            }
+        }
+        return options.mutable !== false
+            ? new MutableImport(scope, id)
+            : new ImmutableImport(scope, id);
+    }
+    /**
+     * Look up a security group.
+     */
+    static fromLookupAttributes(scope, id, options) {
+        if (cdktf_1.Token.isUnresolved(options.securityGroupId) ||
+            cdktf_1.Token.isUnresolved(options.securityGroupName) ||
+            cdktf_1.Token.isUnresolved(options.vpc?.vpcId)) {
+            throw new Error("All arguments to look up a security group must be concrete (no Tokens)");
+        }
+        const data = new provider_aws_1.dataAwsSecurityGroup.DataAwsSecurityGroup(scope, id, {
+            vpcId: options.vpc?.vpcId,
+            id: options.securityGroupId,
+            name: options.securityGroupName,
+        });
+        // TODO: Use Grid as contextProvider
+        // Warning: using data source to determine if the security group allows
+        // all outbound with allowAllOutboundLocal(scope, id, data.id)
+        // would force all depending code to deal with Tokens
+        return SecurityGroup.fromSecurityGroupId(scope, id, data.id, {
+            allowAllOutbound: options.allowAllOutbound ?? true,
+            mutable: true,
+        });
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.directIngressRules = [];
+        this.directEgressRules = [];
+        const groupName = props.securityGroupName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+            });
+        const groupDescription = props.description || this.node.path;
+        this.allowAllOutbound = props.allowAllOutbound !== false;
+        this.allowAllIpv6Outbound = props.allowAllIpv6Outbound ?? false;
+        this.disableInlineRules =
+            props.disableInlineRules !== undefined
+                ? !!props.disableInlineRules
+                : !!this.node.tryGetContext(SECURITY_GROUP_DISABLE_INLINE_RULES_CONTEXT_KEY);
+        this.securityGroup = new provider_aws_1.securityGroup.SecurityGroup(this, "Resource", {
+            name: groupName,
+            description: groupDescription,
+            ingress: cdktf_1.Lazy.anyValue({
+                produce: () => this.directIngressRules.map(provider_aws_1.securityGroup.securityGroupIngressToTerraform),
+            }, { omitEmptyArray: true }),
+            egress: cdktf_1.Lazy.anyValue({
+                produce: () => this.directEgressRules.map(provider_aws_1.securityGroup.securityGroupEgressToTerraform),
+            }, { omitEmptyArray: true }),
+            vpcId: props.vpc.vpcId,
+        });
+        this.securityGroupId = this.securityGroup.id;
+        this.securityGroupVpcId = this.securityGroup.vpcId;
+        this.addDefaultEgressRule();
+        this.addDefaultIpv6EgressRule();
+    }
+    addIngressRule(peer, connection, description, remoteRule) {
+        if (!peer.canInlineRule ||
+            !connection.canInlineRule ||
+            this.disableInlineRules) {
+            super.addIngressRule(peer, connection, description, remoteRule);
+            return;
+        }
+        if (description === undefined) {
+            description = `from ${peer.uniqueId}:${connection}`;
+        }
+        this.addDirectIngressRule({
+            ...peer.toIngressRuleConfig(),
+            ...connection.toRuleJson(),
+            description,
+        });
+    }
+    addEgressRule(peer, connection, description, remoteRule) {
+        const isIpv6 = peer.toEgressRuleConfig().hasOwnProperty("cidrIpv6");
+        if (!isIpv6 && this.allowAllOutbound) {
+            // In the case of "allowAllOutbound", we don't add any more rules. There
+            // is only one rule which allows all traffic and that subsumes any other
+            // rule.
+            if (!remoteRule) {
+                // Warn only if addEgressRule() was explicitely called
+                // "@aws-cdk/aws-ec2:ipv4IgnoreEgressRule",
+                cdktf_1.Annotations.of(this).addWarning("Ignoring Egress rule since 'allowAllOutbound' is set to true; To add customized rules, set allowAllOutbound=false on the SecurityGroup");
+            }
+            return;
+        }
+        if (isIpv6 && this.allowAllIpv6Outbound) {
+            // In the case of "allowAllIpv6Outbound", we don't add any more rules. There
+            // is only one rule which allows all traffic and that subsumes any other
+            // rule.
+            if (!remoteRule) {
+                // Warn only if addEgressRule() was explicitely called
+                // "@aws-cdk/aws-ec2:ipv6IgnoreEgressRule",
+                cdktf_1.Annotations.of(this).addWarning("Ignoring Egress rule since 'allowAllIpv6Outbound' is set to true; To add customized rules, set allowAllIpv6Outbound=false on the SecurityGroup");
+            }
+            return;
+        }
+        if (!peer.canInlineRule ||
+            !connection.canInlineRule ||
+            this.disableInlineRules) {
+            super.addEgressRule(peer, connection, description, remoteRule);
+            return;
+        }
+        if (description === undefined) {
+            description = `from ${peer.uniqueId}:${connection}`;
+        }
+        const rule = {
+            ...peer.toEgressRuleConfig(),
+            ...connection.toRuleJson(),
+            description,
+        };
+        if (isAllTrafficRule(rule)) {
+            // We cannot allow this; if someone adds the rule in this way, it will be
+            // removed again if they add other rules. We also can't automatically switch
+            // to "allOutbound=true" mode, because we might have already emitted
+            // EgressRule objects (which count as rules added later) and there's no way
+            // to recall those. Better to prevent this for now.
+            throw new Error('Cannot add an "all traffic" egress rule in this way; set allowAllOutbound=true (for ipv6) or allowAllIpv6Outbound=true (for ipv6) on the SecurityGroup instead.');
+        }
+        this.addDirectEgressRule(rule);
+    }
+    /**
+     * Add a direct ingress rule
+     */
+    addDirectIngressRule(rule) {
+        let r = normalizeDirectRule(rule);
+        if (!this.hasIngressRule(r)) {
+            this.directIngressRules.push(r);
+        }
+    }
+    /**
+     * Return whether the given ingress rule exists on the group
+     */
+    hasIngressRule(rule) {
+        return (this.directIngressRules.findIndex((r) => ingressRulesEqual(r, rule)) > -1);
+    }
+    /**
+     * Add a direct egress rule
+     */
+    addDirectEgressRule(rule) {
+        let r = normalizeDirectRule(rule);
+        if (!this.hasEgressRule(r)) {
+            this.directEgressRules.push(r);
+        }
+    }
+    /**
+     * Return whether the given egress rule exists on the group
+     */
+    hasEgressRule(rule) {
+        return (this.directEgressRules.findIndex((r) => egressRulesEqual(r, rule)) > -1);
+    }
+    /**
+     * Add the default egress rule to the securityGroup
+     *
+     * By default, AWS creates an `ALLOW ALL` egress rule when creating a new Security Group inside of a VPC.
+     * When creating a new Security Group inside a VPC, Terraform will remove this default rule, and require
+     * you specifically re-create it if you desire that rule.
+     *
+     * This depends on allowAllOutbound
+     *
+     * - If allowAllOutbound is true, we will add an allow all rule.
+     * - If allowAllOutbound is false, we don't do anything since TF does not add
+     *   a default allow all ipv4 rule.
+     */
+    addDefaultEgressRule() {
+        if (!this.allowAllOutbound) {
+            return;
+        }
+        if (this.disableInlineRules) {
+            super.addEgressRule(ALL_TRAFFIC_PEER, ALL_TRAFFIC_PORT, ALLOW_ALL_RULE.description, false);
+        }
+        else {
+            this.directEgressRules.push(ALLOW_ALL_RULE);
+        }
+    }
+    /**
+     * Add a allow all ipv6 egress rule to the securityGroup
+     *
+     * This depends on allowAllIpv6Outbound:
+     *
+     * - If allowAllIpv6Outbound is true, we will add an allow all rule.
+     * - If allowAllOutbound is false, we don't do anything since EC2 does not add
+     *   a default allow all ipv6 rule.
+     */
+    addDefaultIpv6EgressRule() {
+        const description = "Allow all outbound ipv6 traffic by default";
+        const peer = peer_1.Peer.anyIpv6();
+        if (this.allowAllIpv6Outbound) {
+            if (this.disableInlineRules) {
+                super.addEgressRule(peer, port_1.Port.allTraffic(), description, false);
+            }
+            else {
+                this.directEgressRules.push({
+                    protocol: "-1",
+                    fromPort: 0,
+                    toPort: 0,
+                    ipv6CidrBlocks: [peer.uniqueId],
+                    description,
+                });
+            }
+        }
+    }
+}
+exports.SecurityGroup = SecurityGroup;
+_a = JSII_RTTI_SYMBOL_1;
+SecurityGroup[_a] = { fqn: "terraconstructs.aws.compute.SecurityGroup", version: "0.0.12" };
+/**
+ * Fix up a direct rule to have fromPort/toPort defined
+ */
+function normalizeDirectRule(rule) {
+    // Unlike security_group_(in|e)gress_rule, TF Security Group direct rules
+    // can't have fromPort/toPort undefined.
+    // refs:
+    // - https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/vpc_security_group_egress_rule#ip_protocol-1
+    //   vs
+    // - https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/security_group#protocol-1
+    return {
+        ...rule,
+        fromPort: rule.fromPort ?? 0,
+        toPort: rule.toPort ?? 0,
+    };
+}
+/**
+ * Egress rule that matches all traffic
+ */
+const ALLOW_ALL_RULE = {
+    cidrBlocks: ["0.0.0.0/0"],
+    description: "Allow all outbound traffic by default",
+    /**
+     * If you select a protocol of -1 (semantically equivalent to all, which is not a valid value here),
+     * you must specify a from_port and to_port equal to 0.
+     */
+    protocol: "-1",
+    fromPort: 0,
+    toPort: 0,
+};
+const ALL_TRAFFIC_PEER = peer_1.Peer.anyIpv4();
+const ALL_TRAFFIC_PORT = port_1.Port.allTraffic();
+/**
+ * Compare two ingress rules for equality the same way CloudFormation would (discarding description)
+ */
+function ingressRulesEqual(a, b) {
+    return (a.cidrBlocks === b.cidrBlocks &&
+        a.ipv6CidrBlocks === b.ipv6CidrBlocks &&
+        a.fromPort === b.fromPort &&
+        a.toPort === b.toPort &&
+        a.protocol === b.protocol &&
+        a.prefixListIds === b.prefixListIds &&
+        a.securityGroups === b.securityGroups);
+}
+/**
+ * Compare two egress rules for equality the same way CloudFormation would (discarding description)
+ */
+function egressRulesEqual(a, b) {
+    return (a.cidrBlocks === b.cidrBlocks &&
+        a.ipv6CidrBlocks === b.ipv6CidrBlocks &&
+        a.fromPort === b.fromPort &&
+        a.toPort === b.toPort &&
+        a.protocol === b.protocol &&
+        a.prefixListIds === b.prefixListIds &&
+        a.securityGroups === b.securityGroups);
+}
+/**
+ * Whether this rule refers to all traffic
+ */
+function isAllTrafficRule(rule) {
+    return ((rule.cidrIpv4 === "0.0.0.0/0" ||
+        (rule.cidrBlocks && rule.cidrBlocks[0] === "0.0.0.0/0") ||
+        rule.cidrIpv6 === "::/0") &&
+        rule.ipProtocol === "-1");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-group.js","sourceRoot":"","sources":["../../../src/aws/compute/security-group.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/security-group.ts\n\nimport {\n  dataAwsSecurityGroup,\n  securityGroup,\n  vpcSecurityGroupEgressRule,\n  vpcSecurityGroupIngressRule,\n} from \"@cdktf/provider-aws\";\nimport { Annotations, Lazy, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Connections } from \"./connections\";\nimport { IPeer, Peer } from \"./peer\";\nimport { Port } from \"./port\";\nimport { IVpc } from \"./vpc\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\n// import { allowAllOutboundLocal } from \"./private/context-stub\";\n\nconst SECURITY_GROUP_SYMBOL = Symbol.for(\n  \"terraconstructs/lib/aws/compute.SecurityGroup\",\n);\n\nconst SECURITY_GROUP_DISABLE_INLINE_RULES_CONTEXT_KEY =\n  \"terraconstructs/aws/compute.securityGroupDisableInlineRules\";\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface SecurityGroupOutputs {\n  /**\n   * ID for the current security group\n   * @attribute\n   */\n  readonly securityGroupId: string;\n}\n\n/**\n * Interface for security group-like objects\n */\nexport interface ISecurityGroup extends IAwsConstruct, IPeer {\n  /** Strongly typed outputs */\n  readonly securityGroupOutputs: SecurityGroupOutputs;\n\n  /**\n   * ID for the current security group\n   * @attribute\n   */\n  readonly securityGroupId: string;\n\n  /**\n   * Whether the SecurityGroup has been configured to allow all outbound traffic\n   */\n  readonly allowAllOutbound: boolean;\n\n  /**\n   * Add an ingress rule for the current security group\n   *\n   * `remoteRule` controls where the Rule object is created if the peer is also a\n   * securityGroup and they are in different stack. If false (default) the\n   * rule object is created under the current SecurityGroup object. If true and the\n   * peer is also a SecurityGroup, the rule object is created under the remote\n   * SecurityGroup object.\n   */\n  addIngressRule(\n    peer: IPeer,\n    connection: Port,\n    description?: string,\n    remoteRule?: boolean,\n  ): void;\n\n  /**\n   * Add an egress rule for the current security group\n   *\n   * `remoteRule` controls where the Rule object is created if the peer is also a\n   * securityGroup and they are in different stack. If false (default) the\n   * rule object is created under the current SecurityGroup object. If true and the\n   * peer is also a SecurityGroup, the rule object is created under the remote\n   * SecurityGroup object.\n   */\n  addEgressRule(\n    peer: IPeer,\n    connection: Port,\n    description?: string,\n    remoteRule?: boolean,\n  ): void;\n}\n\n/**\n * A SecurityGroup that is not created in this template\n */\nabstract class SecurityGroupBase\n  extends AwsConstructBase\n  implements ISecurityGroup\n{\n  /**\n   * Return whether the indicated object is a security group\n   */\n  public static isSecurityGroup(x: any): x is SecurityGroupBase {\n    return SECURITY_GROUP_SYMBOL in x;\n  }\n\n  public abstract readonly securityGroupId: string;\n  public get securityGroupOutputs(): SecurityGroupOutputs {\n    return {\n      securityGroupId: this.securityGroupId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.securityGroupOutputs;\n  }\n  public abstract readonly allowAllOutbound: boolean;\n  public abstract readonly allowAllIpv6Outbound: boolean;\n\n  public readonly canInlineRule = false;\n  public readonly connections: Connections = new Connections({\n    securityGroups: [this],\n  });\n  public readonly defaultPort?: Port;\n\n  private peerAsTokenCount: number = 0;\n\n  constructor(scope: Construct, id: string, props?: AwsConstructProps) {\n    super(scope, id, props);\n\n    Object.defineProperty(this, SECURITY_GROUP_SYMBOL, { value: true });\n  }\n\n  public get uniqueId() {\n    return AwsStack.uniqueId(this.node);\n  }\n\n  public addIngressRule(\n    peer: IPeer,\n    connection: Port,\n    description?: string,\n    remoteRule?: boolean,\n  ) {\n    if (description === undefined) {\n      description = `from ${peer.uniqueId}:${connection}`;\n    }\n\n    const { scope, id } = this.determineRuleScope(\n      peer,\n      connection,\n      \"from\",\n      remoteRule,\n    );\n\n    // Skip duplicates\n    if (scope.node.tryFindChild(id) === undefined) {\n      new vpcSecurityGroupIngressRule.VpcSecurityGroupIngressRule(scope, id, {\n        securityGroupId: this.securityGroupId,\n        ...peer.toIngressRuleConfig(),\n        ...connection.toRuleJson(),\n        description,\n      });\n    }\n  }\n\n  public addEgressRule(\n    peer: IPeer,\n    connection: Port,\n    description?: string,\n    remoteRule?: boolean,\n  ) {\n    if (description === undefined) {\n      description = `to ${peer.uniqueId}:${connection}`;\n    }\n\n    const { scope, id } = this.determineRuleScope(\n      peer,\n      connection,\n      \"to\",\n      remoteRule,\n    );\n\n    // Skip duplicates\n    if (scope.node.tryFindChild(id) === undefined) {\n      new vpcSecurityGroupEgressRule.VpcSecurityGroupEgressRule(scope, id, {\n        securityGroupId: this.securityGroupId,\n        ...peer.toEgressRuleConfig(),\n        ...connection.toRuleJson(),\n        description,\n      });\n    }\n  }\n\n  public toIngressRuleConfig(): any {\n    return this.toRuleConfig();\n  }\n\n  public toEgressRuleConfig(): any {\n    return this.toRuleConfig();\n  }\n\n  // Terraform does not use different properties between ingress and egress rules\n  private toRuleConfig(): any {\n    return { referencedSecurityGroupId: this.securityGroupId };\n  }\n\n  /**\n   * Determine where to parent a new ingress/egress rule\n   *\n   * A SecurityGroup rule is parented under the group it's related to, UNLESS\n   * we're in a cross-stack scenario with another Security Group. In that case,\n   * we respect the 'remoteRule' flag and will parent under the other security\n   * group.\n   *\n   * This is necessary to avoid cyclic dependencies between stacks, since both\n   * ingress and egress rules will reference both security groups, and a naive\n   * parenting will lead to the following situation:\n   *\n   *   ╔════════════════════╗         ╔════════════════════╗\n   *   ║  ┌───────────┐     ║         ║    ┌───────────┐   ║\n   *   ║  │  GroupA   │◀────╬─┐   ┌───╬───▶│  GroupB   │   ║\n   *   ║  └───────────┘     ║ │   │   ║    └───────────┘   ║\n   *   ║        ▲           ║ │   │   ║          ▲         ║\n   *   ║        │           ║ │   │   ║          │         ║\n   *   ║        │           ║ │   │   ║          │         ║\n   *   ║  ┌───────────┐     ║ └───┼───╬────┌───────────┐   ║\n   *   ║  │  EgressA  │─────╬─────┘   ║    │ IngressB  │   ║\n   *   ║  └───────────┘     ║         ║    └───────────┘   ║\n   *   ║                    ║         ║                    ║\n   *   ╚════════════════════╝         ╚════════════════════╝\n   *\n   * By having the ability to switch the parent, we avoid the cyclic reference by\n   * keeping all rules in a single stack.\n   *\n   * If this happens, we also have to change the construct ID, because\n   * otherwise we might have two objects with the same ID if we have\n   * multiple reversed security group relationships.\n   *\n   *   ╔═══════════════════════════════════╗\n   *   ║┌───────────┐                      ║\n   *   ║│  GroupB   │                      ║\n   *   ║└───────────┘                      ║\n   *   ║      ▲                            ║\n   *   ║      │              ┌───────────┐ ║\n   *   ║      ├────\"from A\"──│ IngressB  │ ║\n   *   ║      │              └───────────┘ ║\n   *   ║      │              ┌───────────┐ ║\n   *   ║      ├─────\"to B\"───│  EgressA  │ ║\n   *   ║      │              └───────────┘ ║\n   *   ║      │              ┌───────────┐ ║\n   *   ║      └─────\"to B\"───│  EgressC  │ ║  <-- oops\n   *   ║                     └───────────┘ ║\n   *   ╚═══════════════════════════════════╝\n   */\n\n  protected determineRuleScope(\n    peer: IPeer,\n    connection: Port,\n    fromTo: \"from\" | \"to\",\n    remoteRule?: boolean,\n  ): RuleScope {\n    if (\n      remoteRule &&\n      SecurityGroupBase.isSecurityGroup(peer) &&\n      differentStacks(this, peer)\n    ) {\n      // Reversed\n      const reversedFromTo = fromTo === \"from\" ? \"to\" : \"from\";\n      return {\n        scope: peer,\n        id: `${this.uniqueId}:${connection} ${reversedFromTo}`,\n      };\n    } else {\n      // Regular (do old ID escaping in order to not disturb existing deployments)\n      return {\n        scope: this,\n        id: `${fromTo} ${this.renderPeer(peer)}:${connection}`.replace(\n          \"/\",\n          \"_\",\n        ),\n      };\n    }\n  }\n\n  private renderPeer(peer: IPeer) {\n    if (Token.isUnresolved(peer.uniqueId)) {\n      // Need to return a unique value each time a peer\n      // is an unresolved token, else the duplicate skipper\n      // in `sg.addXxxRule` can detect unique rules as duplicates\n      return this.peerAsTokenCount++\n        ? `'{IndirectPeer${this.peerAsTokenCount}}'`\n        : \"{IndirectPeer}\";\n    } else {\n      return peer.uniqueId;\n    }\n  }\n}\n\n/**\n * The scope and id in which a given SecurityGroup rule should be defined.\n */\nexport interface RuleScope {\n  /**\n   * The SecurityGroup in which a rule should be scoped.\n   */\n  readonly scope: ISecurityGroup;\n  /**\n   * The construct ID to use for the rule.\n   */\n  readonly id: string;\n}\n\nfunction differentStacks(group1: SecurityGroupBase, group2: SecurityGroupBase) {\n  return AwsStack.of(group1) !== AwsStack.of(group2);\n}\n\nexport interface SecurityGroupProps extends AwsConstructProps {\n  /**\n   * The name of the security group. For valid values, see the GroupName\n   * parameter of the CreateSecurityGroup action in the Amazon EC2 API\n   * Reference.\n   *\n   * It is not recommended to use an explicit group name.\n   *\n   * @default If you don't specify a GroupName, AWS CloudFormation generates a\n   * unique physical ID and uses that ID for the group name.\n   */\n  readonly securityGroupName?: string;\n\n  /**\n   * A description of the security group.\n   *\n   * Forces new resource\n   *\n   * Security group description. Defaults to `Managed by Terraform`. Cannot be `\"\"`.\n   *\n   * NOTE: This field maps to the AWS `GroupDescription` attribute, for which there is no Update API.\n   * If you'd like to classify your security groups in a way that can be updated, use tags.\n   *\n   * @default The default name will be the construct's CDK path.\n   */\n  readonly description?: string;\n\n  /**\n   * The VPC in which to create the security group.\n   */\n  readonly vpc: IVpc;\n\n  /**\n   * Whether to allow all outbound traffic by default.\n   *\n   * If this is set to true, there will only be a single egress rule which allows all\n   * outbound traffic. If this is set to false, no outbound traffic will be allowed by\n   * default and all egress traffic must be explicitly authorized.\n   *\n   * To allow all ipv6 traffic use allowAllIpv6Outbound\n   *\n   * @default true\n   */\n  readonly allowAllOutbound?: boolean;\n\n  /**\n   * Whether to allow all outbound ipv6 traffic by default.\n   *\n   * If this is set to true, there will only be a single egress rule which allows all\n   * outbound ipv6 traffic. If this is set to false, no outbound traffic will be allowed by\n   * default and all egress ipv6 traffic must be explicitly authorized.\n   *\n   * To allow all ipv4 traffic use allowAllOutbound\n   *\n   * @default false\n   */\n  readonly allowAllIpv6Outbound?: boolean;\n\n  /**\n   * Whether to disable inline ingress and egress rule optimization.\n   *\n   * If this is set to true, ingress and egress rules will not be declared under the\n   * SecurityGroup in cloudformation, but will be separate elements.\n   *\n   * Inlining rules is an optimization for producing smaller stack templates. Sometimes\n   * this is not desirable, for example when security group access is managed via tags.\n   *\n   * The default value can be overriden globally by setting the context variable\n   * '@aws-cdk/aws-ec2.securityGroupDisableInlineRules'.\n   *\n   * @default false\n   */\n  readonly disableInlineRules?: boolean;\n}\n\n/**\n * Additional options for imported security groups\n */\nexport interface SecurityGroupImportOptions {\n  /**\n   * Mark the SecurityGroup as having been created allowing all outbound traffic\n   *\n   * Only if this is set to false will egress rules be added to this security\n   * group. Be aware, this would undo any potential \"all outbound traffic\"\n   * default.\n   *\n   *\n   * @default true\n   */\n  readonly allowAllOutbound?: boolean;\n\n  /**\n   * Mark the SecurityGroup as having been created allowing all outbound ipv6 traffic\n   *\n   * Only if this is set to false will egress rules for ipv6 be added to this security\n   * group. Be aware, this would undo any potential \"all outbound traffic\"\n   * default.\n   *\n   * @default false\n   */\n  readonly allowAllIpv6Outbound?: boolean;\n\n  /**\n   * If a SecurityGroup is mutable CDK can add rules to existing groups\n   *\n   * Beware that making a SecurityGroup immutable might lead to issue\n   * due to missing ingress/egress rules for new resources.\n   *\n   *\n   * @default true\n   */\n  readonly mutable?: boolean;\n}\n\n/**\n * Creates an Amazon EC2 security group within a VPC.\n *\n * Security Groups act like a firewall with a set of rules, and are associated\n * with any AWS resource that has or creates Elastic Network Interfaces (ENIs).\n * A typical example of a resource that has a security group is an Instance (or\n * Auto Scaling Group of instances)\n *\n * If you are defining new infrastructure in CDK, there is a good chance you\n * won't have to interact with this class at all. Like IAM Roles, Security\n * Groups need to exist to control access between AWS resources, but CDK will\n * automatically generate and populate them with least-privilege permissions\n * for you so you can concentrate on your business logic.\n *\n * All Constructs that require Security Groups will create one for you if you\n * don't specify one at construction. After construction, you can selectively\n * allow connections to and between constructs via--for example-- the `instance.connections`\n * object. Think of it as \"allowing connections to your instance\", rather than\n * \"adding ingress rules a security group\". See the [Allowing\n * Connections](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-cdk-lib.aws_ec2-readme.html#allowing-connections)\n * section in the library documentation for examples.\n *\n * Direct manipulation of the Security Group through `addIngressRule` and\n * `addEgressRule` is possible, but mutation through the `.connections` object\n * is recommended. If you peer two constructs with security groups this way,\n * appropriate rules will be created in both.\n *\n * If you have an existing security group you want to use in your CDK application,\n * you would import it like this:\n *\n * ```ts\n * const securityGroup = compute.SecurityGroup.fromSecurityGroupId(this, 'SG', 'sg-12345', {\n *   mutable: false\n * });\n * ```\n */\nexport class SecurityGroup extends SecurityGroupBase {\n  /**\n   * Look up a security group by id.\n   */\n  public static fromLookupById(\n    scope: Construct,\n    id: string,\n    securityGroupId: string,\n    allowAllOutbound?: boolean,\n  ) {\n    return this.fromLookupAttributes(scope, id, {\n      securityGroupId,\n      allowAllOutbound,\n    });\n  }\n\n  /**\n   * Look up a security group by name.\n   */\n  public static fromLookupByName(\n    scope: Construct,\n    id: string,\n    securityGroupName: string,\n    vpc: IVpc,\n    allowAllOutbound?: boolean,\n  ) {\n    return this.fromLookupAttributes(scope, id, {\n      securityGroupName,\n      vpc,\n      allowAllOutbound,\n    });\n  }\n\n  /**\n   * Import an existing security group into this app.\n   *\n   * This method will assume that the Security Group has a rule in it which allows\n   * all outbound traffic, and so will not add egress rules to the imported Security\n   * Group (only ingress rules).\n   *\n   * If your existing Security Group needs to have egress rules added, pass the\n   * `allowAllOutbound: false` option on import.\n   */\n  public static fromSecurityGroupId(\n    scope: Construct,\n    id: string,\n    securityGroupId: string,\n    options: SecurityGroupImportOptions = {},\n  ): ISecurityGroup {\n    class MutableImport extends SecurityGroupBase {\n      public securityGroupId = securityGroupId;\n      public allowAllOutbound = options.allowAllOutbound ?? true;\n      public allowAllIpv6Outbound = options.allowAllIpv6Outbound ?? false;\n\n      public addEgressRule(\n        peer: IPeer,\n        connection: Port,\n        description?: string,\n        remoteRule?: boolean,\n      ) {\n        // Only if allowAllOutbound has been disabled\n        if (options.allowAllOutbound === false) {\n          super.addEgressRule(peer, connection, description, remoteRule);\n        }\n      }\n    }\n\n    class ImmutableImport extends SecurityGroupBase {\n      public securityGroupId = securityGroupId;\n      public allowAllOutbound = options.allowAllOutbound ?? true;\n      public allowAllIpv6Outbound = options.allowAllIpv6Outbound ?? false;\n\n      public addEgressRule(\n        _peer: IPeer,\n        _connection: Port,\n        _description?: string,\n        _remoteRule?: boolean,\n      ) {\n        // do nothing\n      }\n\n      public addIngressRule(\n        _peer: IPeer,\n        _connection: Port,\n        _description?: string,\n        _remoteRule?: boolean,\n      ) {\n        // do nothing\n      }\n    }\n\n    return options.mutable !== false\n      ? new MutableImport(scope, id)\n      : new ImmutableImport(scope, id);\n  }\n\n  /**\n   * Look up a security group.\n   */\n  private static fromLookupAttributes(\n    scope: Construct,\n    id: string,\n    options: SecurityGroupLookupOptions,\n  ) {\n    if (\n      Token.isUnresolved(options.securityGroupId) ||\n      Token.isUnresolved(options.securityGroupName) ||\n      Token.isUnresolved(options.vpc?.vpcId)\n    ) {\n      throw new Error(\n        \"All arguments to look up a security group must be concrete (no Tokens)\",\n      );\n    }\n\n    const data = new dataAwsSecurityGroup.DataAwsSecurityGroup(scope, id, {\n      vpcId: options.vpc?.vpcId,\n      id: options.securityGroupId,\n      name: options.securityGroupName,\n    });\n\n    // TODO: Use Grid as contextProvider\n    // Warning: using data source to determine if the security group allows\n    // all outbound with allowAllOutboundLocal(scope, id, data.id)\n    // would force all depending code to deal with Tokens\n    return SecurityGroup.fromSecurityGroupId(scope, id, data.id, {\n      allowAllOutbound: options.allowAllOutbound ?? true,\n      mutable: true,\n    });\n  }\n\n  /**\n   * The ID of the security group\n   *\n   * @attribute\n   */\n  public readonly securityGroupId: string;\n\n  /**\n   * The VPC ID this security group is part of.\n   *\n   * @attribute\n   */\n  public readonly securityGroupVpcId: string;\n\n  /**\n   * Whether the SecurityGroup has been configured to allow all outbound traffic\n   */\n  public readonly allowAllOutbound: boolean;\n\n  /**\n   * Whether the SecurityGroup has been configured to allow all outbound ipv6 traffic\n   */\n  public readonly allowAllIpv6Outbound: boolean;\n\n  private readonly securityGroup: securityGroup.SecurityGroup;\n  private readonly directIngressRules: securityGroup.SecurityGroupIngress[] =\n    [];\n  private readonly directEgressRules: securityGroup.SecurityGroupEgress[] = [];\n\n  /**\n   * Whether to disable optimization for inline security group rules.\n   */\n  private readonly disableInlineRules: boolean;\n\n  constructor(scope: Construct, id: string, props: SecurityGroupProps) {\n    super(scope, id, props);\n    const groupName =\n      props.securityGroupName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n      });\n\n    const groupDescription = props.description || this.node.path;\n\n    this.allowAllOutbound = props.allowAllOutbound !== false;\n    this.allowAllIpv6Outbound = props.allowAllIpv6Outbound ?? false;\n\n    this.disableInlineRules =\n      props.disableInlineRules !== undefined\n        ? !!props.disableInlineRules\n        : !!this.node.tryGetContext(\n            SECURITY_GROUP_DISABLE_INLINE_RULES_CONTEXT_KEY,\n          );\n\n    this.securityGroup = new securityGroup.SecurityGroup(this, \"Resource\", {\n      name: groupName,\n      description: groupDescription,\n      ingress: Lazy.anyValue(\n        {\n          produce: () =>\n            this.directIngressRules.map(\n              securityGroup.securityGroupIngressToTerraform,\n            ),\n        },\n        { omitEmptyArray: true },\n      ),\n      egress: Lazy.anyValue(\n        {\n          produce: () =>\n            this.directEgressRules.map(\n              securityGroup.securityGroupEgressToTerraform,\n            ),\n        },\n        { omitEmptyArray: true },\n      ),\n      vpcId: props.vpc.vpcId,\n    });\n\n    this.securityGroupId = this.securityGroup.id;\n    this.securityGroupVpcId = this.securityGroup.vpcId;\n\n    this.addDefaultEgressRule();\n    this.addDefaultIpv6EgressRule();\n  }\n\n  public addIngressRule(\n    peer: IPeer,\n    connection: Port,\n    description?: string,\n    remoteRule?: boolean,\n  ) {\n    if (\n      !peer.canInlineRule ||\n      !connection.canInlineRule ||\n      this.disableInlineRules\n    ) {\n      super.addIngressRule(peer, connection, description, remoteRule);\n      return;\n    }\n\n    if (description === undefined) {\n      description = `from ${peer.uniqueId}:${connection}`;\n    }\n\n    this.addDirectIngressRule({\n      ...peer.toIngressRuleConfig(),\n      ...connection.toRuleJson(),\n      description,\n    });\n  }\n\n  public addEgressRule(\n    peer: IPeer,\n    connection: Port,\n    description?: string,\n    remoteRule?: boolean,\n  ) {\n    const isIpv6 = peer.toEgressRuleConfig().hasOwnProperty(\"cidrIpv6\");\n\n    if (!isIpv6 && this.allowAllOutbound) {\n      // In the case of \"allowAllOutbound\", we don't add any more rules. There\n      // is only one rule which allows all traffic and that subsumes any other\n      // rule.\n      if (!remoteRule) {\n        // Warn only if addEgressRule() was explicitely called\n        // \"@aws-cdk/aws-ec2:ipv4IgnoreEgressRule\",\n        Annotations.of(this).addWarning(\n          \"Ignoring Egress rule since 'allowAllOutbound' is set to true; To add customized rules, set allowAllOutbound=false on the SecurityGroup\",\n        );\n      }\n      return;\n    }\n\n    if (isIpv6 && this.allowAllIpv6Outbound) {\n      // In the case of \"allowAllIpv6Outbound\", we don't add any more rules. There\n      // is only one rule which allows all traffic and that subsumes any other\n      // rule.\n      if (!remoteRule) {\n        // Warn only if addEgressRule() was explicitely called\n        // \"@aws-cdk/aws-ec2:ipv6IgnoreEgressRule\",\n        Annotations.of(this).addWarning(\n          \"Ignoring Egress rule since 'allowAllIpv6Outbound' is set to true; To add customized rules, set allowAllIpv6Outbound=false on the SecurityGroup\",\n        );\n      }\n      return;\n    }\n\n    if (\n      !peer.canInlineRule ||\n      !connection.canInlineRule ||\n      this.disableInlineRules\n    ) {\n      super.addEgressRule(peer, connection, description, remoteRule);\n      return;\n    }\n\n    if (description === undefined) {\n      description = `from ${peer.uniqueId}:${connection}`;\n    }\n\n    const rule = {\n      ...peer.toEgressRuleConfig(),\n      ...connection.toRuleJson(),\n      description,\n    };\n\n    if (isAllTrafficRule(rule)) {\n      // We cannot allow this; if someone adds the rule in this way, it will be\n      // removed again if they add other rules. We also can't automatically switch\n      // to \"allOutbound=true\" mode, because we might have already emitted\n      // EgressRule objects (which count as rules added later) and there's no way\n      // to recall those. Better to prevent this for now.\n      throw new Error(\n        'Cannot add an \"all traffic\" egress rule in this way; set allowAllOutbound=true (for ipv6) or allowAllIpv6Outbound=true (for ipv6) on the SecurityGroup instead.',\n      );\n    }\n\n    this.addDirectEgressRule(rule);\n  }\n\n  /**\n   * Add a direct ingress rule\n   */\n  private addDirectIngressRule(rule: securityGroup.SecurityGroupIngress) {\n    let r = normalizeDirectRule(rule);\n    if (!this.hasIngressRule(r)) {\n      this.directIngressRules.push(r);\n    }\n  }\n\n  /**\n   * Return whether the given ingress rule exists on the group\n   */\n  private hasIngressRule(rule: securityGroup.SecurityGroupIngress): boolean {\n    return (\n      this.directIngressRules.findIndex((r) => ingressRulesEqual(r, rule)) > -1\n    );\n  }\n\n  /**\n   * Add a direct egress rule\n   */\n  private addDirectEgressRule(rule: securityGroup.SecurityGroupEgress) {\n    let r = normalizeDirectRule(rule);\n    if (!this.hasEgressRule(r)) {\n      this.directEgressRules.push(r);\n    }\n  }\n\n  /**\n   * Return whether the given egress rule exists on the group\n   */\n  private hasEgressRule(rule: securityGroup.SecurityGroupEgress): boolean {\n    return (\n      this.directEgressRules.findIndex((r) => egressRulesEqual(r, rule)) > -1\n    );\n  }\n\n  /**\n   * Add the default egress rule to the securityGroup\n   *\n   * By default, AWS creates an `ALLOW ALL` egress rule when creating a new Security Group inside of a VPC.\n   * When creating a new Security Group inside a VPC, Terraform will remove this default rule, and require\n   * you specifically re-create it if you desire that rule.\n   *\n   * This depends on allowAllOutbound\n   *\n   * - If allowAllOutbound is true, we will add an allow all rule.\n   * - If allowAllOutbound is false, we don't do anything since TF does not add\n   *   a default allow all ipv4 rule.\n   */\n  private addDefaultEgressRule() {\n    if (!this.allowAllOutbound) {\n      return;\n    }\n    if (this.disableInlineRules) {\n      super.addEgressRule(\n        ALL_TRAFFIC_PEER,\n        ALL_TRAFFIC_PORT,\n        ALLOW_ALL_RULE.description,\n        false,\n      );\n    } else {\n      this.directEgressRules.push(ALLOW_ALL_RULE);\n    }\n  }\n\n  /**\n   * Add a allow all ipv6 egress rule to the securityGroup\n   *\n   * This depends on allowAllIpv6Outbound:\n   *\n   * - If allowAllIpv6Outbound is true, we will add an allow all rule.\n   * - If allowAllOutbound is false, we don't do anything since EC2 does not add\n   *   a default allow all ipv6 rule.\n   */\n  private addDefaultIpv6EgressRule() {\n    const description = \"Allow all outbound ipv6 traffic by default\";\n    const peer = Peer.anyIpv6();\n    if (this.allowAllIpv6Outbound) {\n      if (this.disableInlineRules) {\n        super.addEgressRule(peer, Port.allTraffic(), description, false);\n      } else {\n        this.directEgressRules.push({\n          protocol: \"-1\",\n          fromPort: 0,\n          toPort: 0,\n          ipv6CidrBlocks: [peer.uniqueId],\n          description,\n        });\n      }\n    }\n  }\n}\n\n/**\n * Fix up a direct rule to have fromPort/toPort defined\n */\nfunction normalizeDirectRule(\n  rule: securityGroup.SecurityGroupEgress | securityGroup.SecurityGroupIngress,\n): securityGroup.SecurityGroupEgress | securityGroup.SecurityGroupIngress {\n  // Unlike security_group_(in|e)gress_rule, TF Security Group direct rules\n  // can't have fromPort/toPort undefined.\n  // refs:\n  // - https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/vpc_security_group_egress_rule#ip_protocol-1\n  //   vs\n  // - https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/security_group#protocol-1\n  return {\n    ...rule,\n    fromPort: rule.fromPort ?? 0,\n    toPort: rule.toPort ?? 0,\n  };\n}\n\n/**\n * Egress rule that matches all traffic\n */\nconst ALLOW_ALL_RULE: securityGroup.SecurityGroupEgress = {\n  cidrBlocks: [\"0.0.0.0/0\"],\n  description: \"Allow all outbound traffic by default\",\n  /**\n   * If you select a protocol of -1 (semantically equivalent to all, which is not a valid value here),\n   * you must specify a from_port and to_port equal to 0.\n   */\n  protocol: \"-1\",\n  fromPort: 0,\n  toPort: 0,\n};\n\nconst ALL_TRAFFIC_PEER = Peer.anyIpv4();\nconst ALL_TRAFFIC_PORT = Port.allTraffic();\n\nexport interface ConnectionRule {\n  /**\n   * The IP protocol name (tcp, udp, icmp) or number (see Protocol Numbers).\n   * Use -1 to specify all protocols. If you specify -1, or a protocol number\n   * other than tcp, udp, icmp, or 58 (ICMPv6), traffic on all ports is\n   * allowed, regardless of any ports you specify. For tcp, udp, and icmp, you\n   * must specify a port range. For protocol 58 (ICMPv6), you can optionally\n   * specify a port range; if you don't, traffic for all types and codes is\n   * allowed.\n   *\n   * @default tcp\n   */\n  readonly protocol?: string;\n\n  /**\n   * Start of port range for the TCP and UDP protocols, or an ICMP type number.\n   *\n   * If you specify icmp for the IpProtocol property, you can specify\n   * -1 as a wildcard (i.e., any ICMP type number).\n   */\n  readonly fromPort: number;\n\n  /**\n   * End of port range for the TCP and UDP protocols, or an ICMP code.\n   *\n   * If you specify icmp for the IpProtocol property, you can specify -1 as a\n   * wildcard (i.e., any ICMP code).\n   *\n   * @default If toPort is not specified, it will be the same as fromPort.\n   */\n  readonly toPort?: number;\n\n  /**\n   * Description of this connection. It is applied to both the ingress rule\n   * and the egress rule.\n   *\n   * @default No description\n   */\n  readonly description?: string;\n}\n\n/**\n * Compare two ingress rules for equality the same way CloudFormation would (discarding description)\n */\nfunction ingressRulesEqual(\n  a: securityGroup.SecurityGroupIngress,\n  b: securityGroup.SecurityGroupIngress,\n) {\n  return (\n    a.cidrBlocks === b.cidrBlocks &&\n    a.ipv6CidrBlocks === b.ipv6CidrBlocks &&\n    a.fromPort === b.fromPort &&\n    a.toPort === b.toPort &&\n    a.protocol === b.protocol &&\n    a.prefixListIds === b.prefixListIds &&\n    a.securityGroups === b.securityGroups\n  );\n}\n\n/**\n * Compare two egress rules for equality the same way CloudFormation would (discarding description)\n */\nfunction egressRulesEqual(\n  a: securityGroup.SecurityGroupEgress,\n  b: securityGroup.SecurityGroupEgress,\n) {\n  return (\n    a.cidrBlocks === b.cidrBlocks &&\n    a.ipv6CidrBlocks === b.ipv6CidrBlocks &&\n    a.fromPort === b.fromPort &&\n    a.toPort === b.toPort &&\n    a.protocol === b.protocol &&\n    a.prefixListIds === b.prefixListIds &&\n    a.securityGroups === b.securityGroups\n  );\n}\n\n/**\n * Whether this rule refers to all traffic\n */\nfunction isAllTrafficRule(rule: any) {\n  return (\n    (rule.cidrIpv4 === \"0.0.0.0/0\" ||\n      (rule.cidrBlocks && rule.cidrBlocks[0] === \"0.0.0.0/0\") ||\n      rule.cidrIpv6 === \"::/0\") &&\n    rule.ipProtocol === \"-1\"\n  );\n}\n\n/**\n * Properties for looking up an existing SecurityGroup.\n *\n * Either `securityGroupName` or `securityGroupId` has to be specified.\n */\ninterface SecurityGroupLookupOptions {\n  /**\n   * The name of the security group\n   *\n   * If given, will import the SecurityGroup with this name.\n   *\n   * @default Don't filter on securityGroupName\n   */\n  readonly securityGroupName?: string;\n\n  /**\n   * The ID of the security group\n   *\n   * If given, will import the SecurityGroup with this ID.\n   *\n   * @default Don't filter on securityGroupId\n   */\n  readonly securityGroupId?: string;\n\n  /**\n   * The VPC of the security group\n   *\n   * If given, will filter the SecurityGroup based on the VPC.\n   *\n   * @default Don't filter on VPC\n   */\n  readonly vpc?: IVpc;\n\n  /**\n   * Mark the SecurityGroup as allowing all outbound traffic\n   *\n   * Only if this is set to false will egress rules be added to this security\n   * group. Be aware, this would undo any potential \"all outbound traffic\"\n   * default.\n   *\n   * @default true\n   */\n  readonly allowAllOutbound?: boolean; // TODO: Use Grid as contextProvider\n}\n"]}