@csermet/multiprovider/dist/services/wafV2WebAcl/utils.js

cloud-graph provider plugin for AWS used to fetch AWS cloud data.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatFirewallManagerRuleGroups = exports.formatDefaultAction = exports.formatVisibilityConfig = exports.formatRuleLabels = exports.formatRuleOverrideAction = exports.formatRuleAction = exports.formatRuleStatement = exports.formatFieldToMatch = exports.formatSearchString = exports.mapTextTransformations = void 0;
const sdk_1 = require("@cloudgraph/sdk");
const buffer_1 = require("buffer");
const lodash_1 = require("lodash");
/**
 * WafV2WebAcl
 */
const mapTextTransformations = (transforms = []) => {
    return transforms.map(transform => ({
        id: sdk_1.generateUniqueId({
            ...transform,
        }),
        priority: transform.Priority,
        type: transform.Type,
    }));
};
exports.mapTextTransformations = mapTextTransformations;
const formatSearchString = (searchString = '') => {
    if (searchString instanceof buffer_1.Blob) {
        return 'blob';
    }
    if (searchString instanceof Uint8Array) {
        return Buffer.from(searchString).toString();
    }
    if (searchString instanceof Buffer) {
        return searchString.toString();
    }
    return searchString;
};
exports.formatSearchString = formatSearchString;
const formatFieldToMatch = (fieldToMatch) => {
    return {
        id: sdk_1.generateUniqueId({
            ...fieldToMatch,
        }),
        singleHeader: {
            name: fieldToMatch?.SingleHeader?.Name,
        },
        singleQueryArgument: {
            name: fieldToMatch?.SingleQueryArgument?.Name,
        },
        // TODO: can we support UriPath, AllQueryArguments, QueryString, Body, Method, JsonBody?
    };
};
exports.formatFieldToMatch = formatFieldToMatch;
const formatRuleStatement = (statement = {}) => {
    if (lodash_1.isEmpty(statement)) {
        return null;
    }
    const { ByteMatchStatement, SqliMatchStatement, XssMatchStatement, SizeConstraintStatement, GeoMatchStatement, RuleGroupReferenceStatement, IPSetReferenceStatement, RegexPatternSetReferenceStatement, RateBasedStatement, AndStatement, OrStatement, NotStatement, ManagedRuleGroupStatement, LabelMatchStatement, } = statement;
    const formattedByteMatchStatement = {
        searchString: exports.formatSearchString(ByteMatchStatement?.SearchString),
        fieldToMatch: exports.formatFieldToMatch(ByteMatchStatement?.FieldToMatch),
        textTransformations: exports.mapTextTransformations(ByteMatchStatement?.TextTransformations ?? []),
        positionalConstraint: ByteMatchStatement?.PositionalConstraint,
    };
    const formattedSqliMatchStatement = {
        fieldToMatch: exports.formatFieldToMatch(SqliMatchStatement?.FieldToMatch),
        textTransformations: exports.mapTextTransformations(SqliMatchStatement?.TextTransformations),
    };
    const formattedXssMatchStatement = {
        fieldToMatch: exports.formatFieldToMatch(XssMatchStatement?.FieldToMatch),
        textTransformations: exports.mapTextTransformations(XssMatchStatement?.TextTransformations),
    };
    const formattedSizeContraint = {
        size: SizeConstraintStatement?.Size,
        comparisonOperator: SizeConstraintStatement?.ComparisonOperator,
        fieldToMatch: exports.formatFieldToMatch(SizeConstraintStatement?.FieldToMatch),
        textTransformations: exports.mapTextTransformations(SizeConstraintStatement?.TextTransformations),
    };
    const formattedGeoMatchStatement = {
        countryCodes: GeoMatchStatement?.CountryCodes,
        forwardedIpConfig: {
            headerName: GeoMatchStatement?.ForwardedIPConfig?.HeaderName,
            fallbackBehavior: GeoMatchStatement?.ForwardedIPConfig?.FallbackBehavior,
        },
    };
    const formattedRuleGroupReferenceStatement = {
        arn: RuleGroupReferenceStatement?.ARN,
        excludedRules: RuleGroupReferenceStatement?.ExcludedRules?.map(excludedRule => ({
            id: sdk_1.generateUniqueId({
                arn: RuleGroupReferenceStatement?.ARN,
                ...excludedRule,
            }),
            name: excludedRule.Name,
        })),
    };
    const formattedIpSetReferenceStatement = {
        arn: IPSetReferenceStatement?.ARN,
        iPSetForwardedIPConfig: {
            headerName: IPSetReferenceStatement?.IPSetForwardedIPConfig?.HeaderName,
            fallbackBehavior: IPSetReferenceStatement?.IPSetForwardedIPConfig?.FallbackBehavior,
            position: IPSetReferenceStatement?.IPSetForwardedIPConfig?.Position,
        },
    };
    const formattedRegexPatternSetReferenceStatement = {
        arn: RegexPatternSetReferenceStatement?.ARN,
        fieldToMatch: exports.formatFieldToMatch(RegexPatternSetReferenceStatement?.FieldToMatch),
        textTransformations: exports.mapTextTransformations(RegexPatternSetReferenceStatement?.TextTransformations),
    };
    const formattedRateBasedStatement = {
        limit: RateBasedStatement?.Limit,
        aggregateKeyType: RateBasedStatement?.AggregateKeyType,
        forwardedIpConfig: {
            headerName: RateBasedStatement?.ForwardedIPConfig?.HeaderName,
            fallbackBehavior: RateBasedStatement?.ForwardedIPConfig?.FallbackBehavior,
        },
        statement: exports.formatRuleStatement(RateBasedStatement?.ScopeDownStatement),
    };
    const formattedAndStatement = {
        statements: AndStatement?.Statements?.map(exports.formatRuleStatement),
    };
    const formattedOrStatement = {
        statements: OrStatement?.Statements?.map(exports.formatRuleStatement),
    };
    const formattedNotStatement = {
        statement: exports.formatRuleStatement(NotStatement?.Statement),
    };
    const formattedManagedRuleGroupStatement = {
        vendorName: ManagedRuleGroupStatement?.VendorName,
        name: ManagedRuleGroupStatement?.Name,
        version: ManagedRuleGroupStatement?.Version,
        excludedRules: ManagedRuleGroupStatement?.ExcludedRules?.map(excludedRule => ({
            id: sdk_1.generateUniqueId({
                ...excludedRule,
            }),
            name: excludedRule.Name,
        })),
        scopedDownStatement: exports.formatRuleStatement(ManagedRuleGroupStatement?.ScopeDownStatement),
    };
    const formattedLabelMatchStatement = {
        scope: LabelMatchStatement?.Scope,
        key: LabelMatchStatement?.Key,
    };
    return {
        id: sdk_1.generateUniqueId({
            ...statement,
        }),
        byteMatchStatement: formattedByteMatchStatement,
        sqliMatchStatement: formattedSqliMatchStatement,
        xssMatchStatement: formattedXssMatchStatement,
        sizeConstraintStatement: formattedSizeContraint,
        geoMatchStatement: formattedGeoMatchStatement,
        ruleGroupReferenceStatement: formattedRuleGroupReferenceStatement,
        iPSetReferenceStatement: formattedIpSetReferenceStatement,
        regexPatternSetReferenceStatement: formattedRegexPatternSetReferenceStatement,
        rateBasedStatement: formattedRateBasedStatement,
        andStatement: formattedAndStatement,
        orStatement: formattedOrStatement,
        notStatement: formattedNotStatement,
        managedRuleGroupStatement: formattedManagedRuleGroupStatement,
        labelMatchStatement: formattedLabelMatchStatement,
    };
};
exports.formatRuleStatement = formatRuleStatement;
const formatRuleAction = (action = {}) => {
    const { Block, Allow, Count } = action;
    const block = {
        customResponse: {
            responseCode: Block?.CustomResponse?.ResponseCode,
            customResponseBodyKey: Block?.CustomResponse?.CustomResponseBodyKey,
            responseHeaders: Block?.CustomResponse?.ResponseHeaders?.map(header => ({
                id: sdk_1.generateUniqueId({
                    ...action,
                }),
                name: header.Name,
                value: header.Value,
            })),
        },
    };
    const allow = {
        customRequestHandling: {
            insertHeaders: Allow?.CustomRequestHandling?.InsertHeaders?.map(header => ({
                id: sdk_1.generateUniqueId({
                    ...header,
                }),
                name: header.Name,
                value: header.Value,
            })),
        },
    };
    const count = {
        customRequestHandling: {
            insertHeaders: Count?.CustomRequestHandling?.InsertHeaders?.map(header => ({
                id: sdk_1.generateUniqueId({
                    ...header,
                }),
                name: header.Name,
                value: header.Value,
            })),
        },
    };
    return {
        block,
        allow,
        count,
    };
};
exports.formatRuleAction = formatRuleAction;
const formatRuleOverrideAction = (action = {}) => {
    const { Count, None } = action;
    const count = {
        customRequestHandling: {
            insertHeaders: Count?.CustomRequestHandling?.InsertHeaders?.map(header => ({
                id: sdk_1.generateUniqueId({
                    ...header,
                }),
                name: header.Name,
                value: header.Value,
            })),
        },
    };
    const none = !!None;
    return {
        count,
        none,
    };
};
exports.formatRuleOverrideAction = formatRuleOverrideAction;
const formatRuleLabels = (labels) => {
    return labels?.map(label => ({
        id: sdk_1.generateUniqueId({
            ...label,
        }),
        name: label.Name,
    }));
};
exports.formatRuleLabels = formatRuleLabels;
const formatVisibilityConfig = (config) => {
    return {
        sampledRequestsEnabled: config?.SampledRequestsEnabled,
        cloudWatchMetricsEnabled: config?.CloudWatchMetricsEnabled,
        metricName: config?.MetricName,
    };
};
exports.formatVisibilityConfig = formatVisibilityConfig;
const formatDefaultAction = (action = {}) => {
    const { Block, Allow } = action;
    const block = {
        customResponse: {
            responseCode: Block?.CustomResponse?.ResponseCode,
            customResponseBodyKey: Block?.CustomResponse?.CustomResponseBodyKey,
            responseHeaders: Block?.CustomResponse?.ResponseHeaders?.map(header => ({
                id: sdk_1.generateUniqueId({
                    ...Block?.CustomResponse,
                    ...header,
                }),
                name: header.Name,
                value: header.Value,
            })),
        },
    };
    const allow = {
        customRequestHandling: {
            insertHeaders: Allow?.CustomRequestHandling?.InsertHeaders?.map(header => ({
                id: sdk_1.generateUniqueId({
                    ...Allow?.CustomRequestHandling,
                    ...header,
                }),
                name: header.Name,
                value: header.Value,
            })),
        },
    };
    return {
        block,
        allow,
    };
};
exports.formatDefaultAction = formatDefaultAction;
const formatFirewallManagerRuleGroups = (ruleGroups) => {
    return ruleGroups?.map(ruleGroup => ({
        id: sdk_1.generateUniqueId({
            ...ruleGroup,
        }),
        name: ruleGroup.Name,
        priority: ruleGroup.Priority,
        firewallManagerStatement: {
            managedRuleGroupStatement: {
                vendorName: ruleGroup?.FirewallManagerStatement?.ManagedRuleGroupStatement
                    ?.VendorName,
                name: ruleGroup?.FirewallManagerStatement?.ManagedRuleGroupStatement
                    ?.Name,
                version: ruleGroup?.FirewallManagerStatement?.ManagedRuleGroupStatement
                    ?.Version,
                excludedRules: ruleGroup?.FirewallManagerStatement?.ManagedRuleGroupStatement?.ExcludedRules?.map(excludedRule => ({
                    id: sdk_1.generateUniqueId({
                        ...excludedRule,
                    }),
                    name: excludedRule.Name,
                })),
                scopedDownStatement: exports.formatRuleStatement(ruleGroup?.FirewallManagerStatement?.ManagedRuleGroupStatement
                    ?.ScopeDownStatement),
            },
            ruleGroupReferenceStatement: {
                arn: ruleGroup?.FirewallManagerStatement?.RuleGroupReferenceStatement
                    ?.ARN,
                excludedRules: ruleGroup?.FirewallManagerStatement?.RuleGroupReferenceStatement?.ExcludedRules?.map(excludedRule => ({
                    id: sdk_1.generateUniqueId({
                        ...excludedRule,
                    }),
                    name: excludedRule.Name,
                })),
            },
        },
        overrideAction: exports.formatRuleOverrideAction(ruleGroup?.OverrideAction),
        visibilityConfig: exports.formatVisibilityConfig(ruleGroup?.VisibilityConfig),
    }));
};
exports.formatFirewallManagerRuleGroups = formatFirewallManagerRuleGroups;