@aws-cdk/aws-ec2/lib/security-group.js

The CDK Construct Library for AWS::EC2

"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.SecurityGroup = void 0;
const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const cxschema = require("@aws-cdk/cloud-assembly-schema");
const core_1 = require("@aws-cdk/core");
const connections_1 = require("./connections");
const ec2_generated_1 = require("./ec2.generated");
const peer_1 = require("./peer");
const port_1 = require("./port");
const SECURITY_GROUP_SYMBOL = Symbol.for('@aws-cdk/iam.SecurityGroup');
const SECURITY_GROUP_DISABLE_INLINE_RULES_CONTEXT_KEY = '@aws-cdk/aws-ec2.securityGroupDisableInlineRules';
/**
 * A SecurityGroup that is not created in this template
 */
class SecurityGroupBase extends core_1.Resource {
    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 });
    }
    /**
     * Return whether the indicated object is a security group
     */
    static isSecurityGroup(x) {
        return SECURITY_GROUP_SYMBOL in x;
    }
    get uniqueId() {
        return core_1.Names.nodeUniqueId(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 ec2_generated_1.CfnSecurityGroupIngress(scope, id, {
                groupId: 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 ec2_generated_1.CfnSecurityGroupEgress(scope, id, {
                groupId: this.securityGroupId,
                ...peer.toEgressRuleConfig(),
                ...connection.toRuleJson(),
                description,
            });
        }
    }
    toIngressRuleConfig() {
        return { sourceSecurityGroupId: this.securityGroupId };
    }
    toEgressRuleConfig() {
        return { destinationSecurityGroupId: 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 [peer, `${this.uniqueId}:${connection} ${reversedFromTo}`];
        }
        else {
            // Regular (do old ID escaping to in order to not disturb existing deployments)
            return [this, `${fromTo} ${this.renderPeer(peer)}:${connection}`.replace('/', '_')];
        }
    }
    renderPeer(peer) {
        if (core_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 core_1.Stack.of(group1) !== core_1.Stack.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-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 = ec2.SecurityGroup.fromSecurityGroupId(this, 'SG', 'sg-12345', {
 *   mutable: false
 * });
 * ```
 */
class SecurityGroup extends SecurityGroupBase {
    constructor(scope, id, props) {
        super(scope, id, {
            physicalName: props.securityGroupName,
        });
        this.directIngressRules = [];
        this.directEgressRules = [];
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_ec2_SecurityGroupProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, SecurityGroup);
            }
            throw error;
        }
        const groupDescription = props.description || this.node.path;
        this.allowAllOutbound = props.allowAllOutbound !== false;
        this.disableInlineRules = props.disableInlineRules !== undefined ?
            !!props.disableInlineRules :
            !!this.node.tryGetContext(SECURITY_GROUP_DISABLE_INLINE_RULES_CONTEXT_KEY);
        this.securityGroup = new ec2_generated_1.CfnSecurityGroup(this, 'Resource', {
            groupName: this.physicalName,
            groupDescription,
            securityGroupIngress: core_1.Lazy.any({ produce: () => this.directIngressRules }, { omitEmptyArray: true }),
            securityGroupEgress: core_1.Lazy.any({ produce: () => this.directEgressRules }, { omitEmptyArray: true }),
            vpcId: props.vpc.vpcId,
        });
        this.securityGroupId = this.securityGroup.attrGroupId;
        this.securityGroupVpcId = this.securityGroup.attrVpcId;
        this.securityGroupName = this.securityGroup.ref;
        this.addDefaultEgressRule();
    }
    /**
     * Look up a security group by id.
     *
     * @deprecated Use `fromLookupById()` instead
     */
    static fromLookup(scope, id, securityGroupId) {
        try {
            jsiiDeprecationWarnings.print("@aws-cdk/aws-ec2.SecurityGroup#fromLookup", "Use `fromLookupById()` instead");
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.fromLookup);
            }
            throw error;
        }
        return this.fromLookupAttributes(scope, id, { securityGroupId });
    }
    /**
     * Look up a security group by id.
     */
    static fromLookupById(scope, id, securityGroupId) {
        return this.fromLookupAttributes(scope, id, { securityGroupId });
    }
    /**
     * Look up a security group by name.
     */
    static fromLookupByName(scope, id, securityGroupName, vpc) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_ec2_IVpc(vpc);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.fromLookupByName);
            }
            throw error;
        }
        return this.fromLookupAttributes(scope, id, { securityGroupName, vpc });
    }
    /**
     * 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 = {}) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_ec2_SecurityGroupImportOptions(options);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.fromSecurityGroupId);
            }
            throw error;
        }
        class MutableImport extends SecurityGroupBase {
            constructor() {
                super(...arguments);
                this.securityGroupId = securityGroupId;
                this.allowAllOutbound = options.allowAllOutbound ?? true;
            }
            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;
            }
            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 (core_1.Token.isUnresolved(options.securityGroupId) || core_1.Token.isUnresolved(options.securityGroupName) || core_1.Token.isUnresolved(options.vpc?.vpcId)) {
            throw new Error('All arguments to look up a security group must be concrete (no Tokens)');
        }
        const attributes = core_1.ContextProvider.getValue(scope, {
            provider: cxschema.ContextProvider.SECURITY_GROUP_PROVIDER,
            props: {
                securityGroupId: options.securityGroupId,
                securityGroupName: options.securityGroupName,
                vpcId: options.vpc?.vpcId,
            },
            dummyValue: {
                securityGroupId: 'sg-12345',
                allowAllOutbound: true,
            },
        }).value;
        return SecurityGroup.fromSecurityGroupId(scope, id, attributes.securityGroupId, {
            allowAllOutbound: attributes.allowAllOutbound,
            mutable: true,
        });
    }
    addIngressRule(peer, connection, description, remoteRule) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_ec2_IPeer(peer);
            jsiiDeprecationWarnings._aws_cdk_aws_ec2_Port(connection);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.addIngressRule);
            }
            throw error;
        }
        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) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_ec2_IPeer(peer);
            jsiiDeprecationWarnings._aws_cdk_aws_ec2_Port(connection);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.addEgressRule);
            }
            throw error;
        }
        if (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
                core_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;
        }
        else {
            // Otherwise, if the bogus rule exists we can now remove it because the
            // presence of any other rule will get rid of EC2's implicit "all
            // outbound" rule anyway.
            this.removeNoTrafficRule();
        }
        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 on the SecurityGroup instead.');
        }
        this.addDirectEgressRule(rule);
    }
    /**
     * Add a direct ingress rule
     */
    addDirectIngressRule(rule) {
        if (!this.hasIngressRule(rule)) {
            this.directIngressRules.push(rule);
        }
    }
    /**
     * 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) {
        if (!this.hasEgressRule(rule)) {
            this.directEgressRules.push(rule);
        }
    }
    /**
     * 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
     *
     * This depends on allowAllOutbound:
     *
     * - If allowAllOutbound is true, we *TECHNICALLY* don't need to do anything, because
     *   EC2 is going to create this default rule anyway. But, for maximum readability
     *   of the template, we will add one anyway.
     * - If allowAllOutbound is false, we add a bogus rule that matches no traffic in
     *   order to get rid of the default "all outbound" rule that EC2 creates by default.
     *   If other rules happen to get added later, we remove the bogus rule again so
     *   that it doesn't clutter up the template too much (even though that's not
     *   strictly necessary).
     */
    addDefaultEgressRule() {
        if (this.disableInlineRules) {
            const peer = this.allowAllOutbound ? ALL_TRAFFIC_PEER : NO_TRAFFIC_PEER;
            const port = this.allowAllOutbound ? ALL_TRAFFIC_PORT : NO_TRAFFIC_PORT;
            const description = this.allowAllOutbound ? ALLOW_ALL_RULE.description : MATCH_NO_TRAFFIC.description;
            super.addEgressRule(peer, port, description, false);
        }
        else {
            const rule = this.allowAllOutbound ? ALLOW_ALL_RULE : MATCH_NO_TRAFFIC;
            this.directEgressRules.push(rule);
        }
    }
    /**
     * Remove the bogus rule if it exists
     */
    removeNoTrafficRule() {
        if (this.disableInlineRules) {
            const [scope, id] = this.determineRuleScope(NO_TRAFFIC_PEER, NO_TRAFFIC_PORT, 'to', false);
            scope.node.tryRemoveChild(id);
        }
        else {
            const i = this.directEgressRules.findIndex(r => egressRulesEqual(r, MATCH_NO_TRAFFIC));
            if (i > -1) {
                this.directEgressRules.splice(i, 1);
            }
        }
    }
}
exports.SecurityGroup = SecurityGroup;
_a = JSII_RTTI_SYMBOL_1;
SecurityGroup[_a] = { fqn: "@aws-cdk/aws-ec2.SecurityGroup", version: "1.204.0" };
/**
 * Egress rule that purposely matches no traffic
 *
 * This is used in order to disable the "all traffic" default of Security Groups.
 *
 * No machine can ever actually have the 255.255.255.255 IP address, but
 * in order to lock it down even more we'll restrict to a nonexistent
 * ICMP traffic type.
 */
const MATCH_NO_TRAFFIC = {
    cidrIp: '255.255.255.255/32',
    description: 'Disallow all traffic',
    ipProtocol: 'icmp',
    fromPort: 252,
    toPort: 86,
};
const NO_TRAFFIC_PEER = peer_1.Peer.ipv4(MATCH_NO_TRAFFIC.cidrIp);
const NO_TRAFFIC_PORT = port_1.Port.icmpTypeAndCode(MATCH_NO_TRAFFIC.fromPort, MATCH_NO_TRAFFIC.toPort);
/**
 * Egress rule that matches all traffic
 */
const ALLOW_ALL_RULE = {
    cidrIp: '0.0.0.0/0',
    description: 'Allow all outbound traffic by default',
    ipProtocol: '-1',
};
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.cidrIp === b.cidrIp
        && a.cidrIpv6 === b.cidrIpv6
        && a.fromPort === b.fromPort
        && a.toPort === b.toPort
        && a.ipProtocol === b.ipProtocol
        && a.sourceSecurityGroupId === b.sourceSecurityGroupId
        && a.sourceSecurityGroupName === b.sourceSecurityGroupName
        && a.sourceSecurityGroupOwnerId === b.sourceSecurityGroupOwnerId;
}
/**
 * Compare two egress rules for equality the same way CloudFormation would (discarding description)
 */
function egressRulesEqual(a, b) {
    return a.cidrIp === b.cidrIp
        && a.cidrIpv6 === b.cidrIpv6
        && a.fromPort === b.fromPort
        && a.toPort === b.toPort
        && a.ipProtocol === b.ipProtocol
        && a.destinationPrefixListId === b.destinationPrefixListId
        && a.destinationSecurityGroupId === b.destinationSecurityGroupId;
}
/**
 * Whether this rule refers to all traffic
 */
function isAllTrafficRule(rule) {
    return rule.cidrIp === '0.0.0.0/0' && rule.ipProtocol === '-1';
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-group.js","sourceRoot":"","sources":["security-group.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport { Annotations, ContextProvider, IResource, Lazy, Names, Resource, ResourceProps, Stack, Token } from '@aws-cdk/core';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport { Construct } from 'constructs';\nimport { Connections } from './connections';\nimport { CfnSecurityGroup, CfnSecurityGroupEgress, CfnSecurityGroupIngress } from './ec2.generated';\nimport { IPeer, Peer } from './peer';\nimport { Port } from './port';\nimport { IVpc } from './vpc';\n\nconst SECURITY_GROUP_SYMBOL = Symbol.for('@aws-cdk/iam.SecurityGroup');\n\nconst SECURITY_GROUP_DISABLE_INLINE_RULES_CONTEXT_KEY = '@aws-cdk/aws-ec2.securityGroupDisableInlineRules';\n\n/**\n * Interface for security group-like objects\n */\nexport interface ISecurityGroup extends IResource, IPeer {\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(peer: IPeer, connection: Port, description?: string, remoteRule?: boolean): 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(peer: IPeer, connection: Port, description?: string, remoteRule?: boolean): void;\n}\n\n/**\n * A SecurityGroup that is not created in this template\n */\nabstract class SecurityGroupBase extends Resource implements ISecurityGroup {\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 abstract readonly allowAllOutbound: boolean;\n\n  public readonly canInlineRule = false;\n  public readonly connections: Connections = new Connections({ securityGroups: [this] });\n  public readonly defaultPort?: Port;\n\n  private peerAsTokenCount: number = 0;\n\n  constructor(scope: Construct, id: string, props?: ResourceProps) {\n    super(scope, id, props);\n\n    Object.defineProperty(this, SECURITY_GROUP_SYMBOL, { value: true });\n  }\n\n  public get uniqueId() {\n    return Names.nodeUniqueId(this.node);\n  }\n\n  public addIngressRule(peer: IPeer, connection: Port, description?: string, remoteRule?: boolean) {\n    if (description === undefined) {\n      description = `from ${peer.uniqueId}:${connection}`;\n    }\n\n    const [scope, id] = this.determineRuleScope(peer, connection, 'from', remoteRule);\n\n    // Skip duplicates\n    if (scope.node.tryFindChild(id) === undefined) {\n      new CfnSecurityGroupIngress(scope, id, {\n        groupId: this.securityGroupId,\n        ...peer.toIngressRuleConfig(),\n        ...connection.toRuleJson(),\n        description,\n      });\n    }\n  }\n\n  public addEgressRule(peer: IPeer, connection: Port, description?: string, remoteRule?: boolean) {\n    if (description === undefined) {\n      description = `to ${peer.uniqueId}:${connection}`;\n    }\n\n    const [scope, id] = this.determineRuleScope(peer, connection, 'to', remoteRule);\n\n    // Skip duplicates\n    if (scope.node.tryFindChild(id) === undefined) {\n      new CfnSecurityGroupEgress(scope, id, {\n        groupId: this.securityGroupId,\n        ...peer.toEgressRuleConfig(),\n        ...connection.toRuleJson(),\n        description,\n      });\n    }\n  }\n\n  public toIngressRuleConfig(): any {\n    return { sourceSecurityGroupId: this.securityGroupId };\n  }\n\n  public toEgressRuleConfig(): any {\n    return { destinationSecurityGroupId: 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): [SecurityGroupBase, string] {\n\n    if (remoteRule && SecurityGroupBase.isSecurityGroup(peer) && differentStacks(this, peer)) {\n      // Reversed\n      const reversedFromTo = fromTo === 'from' ? 'to' : 'from';\n      return [peer, `${this.uniqueId}:${connection} ${reversedFromTo}`];\n    } else {\n      // Regular (do old ID escaping to in order to not disturb existing deployments)\n      return [this, `${fromTo} ${this.renderPeer(peer)}:${connection}`.replace('/', '_')];\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++ ? `'{IndirectPeer${this.peerAsTokenCount}}'` : '{IndirectPeer}';\n    } else {\n      return peer.uniqueId;\n    }\n  }\n}\n\nfunction differentStacks(group1: SecurityGroupBase, group2: SecurityGroupBase) {\n  return Stack.of(group1) !== Stack.of(group2);\n}\n\nexport interface SecurityGroupProps {\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   * @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