@mitre/hdf-converters 2.6.21 → 2.6.24

package/lib/index.d.ts

@@ -1,10 +1,11 @@
-export * from './src/asff-mapper';
+export { ASFFResults } from './src/asff-mapper/asff-mapper';
 export * from './src/aws-config-mapper';
 export * from './src/burpsuite-mapper';
 export * from './src/converters-from-hdf/asff/reverse-asff-mapper';
 export * from './src/converters-from-hdf/splunk/reverse-splunk-mapper';
 export * from './src/dbprotect-mapper';
 export * from './src/fortify-mapper';
+export * from './src/ionchannel-mapper';
 export * from './src/jfrog-xray-mapper';
 export * as AwsConfigMappingData from './src/mappings/AwsConfigMappingData';
 export * as CciNistMappingData from './src/mappings/CciNistMappingData';

package/lib/index.js

@@ -26,14 +26,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScoutsuiteNistMappingData = exports.OWaspNistMappingData = exports.NiktoNistMappingData = exports.NessusPluginNistMappingData = exports.CweNistMappingData = exports.CciNistMappingData = exports.AwsConfigMappingData = void 0;
-__exportStar(require("./src/asff-mapper"), exports);
+exports.ScoutsuiteNistMappingData = exports.OWaspNistMappingData = exports.NiktoNistMappingData = exports.NessusPluginNistMappingData = exports.CweNistMappingData = exports.CciNistMappingData = exports.AwsConfigMappingData = exports.ASFFResults = void 0;
+var asff_mapper_1 = require("./src/asff-mapper/asff-mapper");
+Object.defineProperty(exports, "ASFFResults", { enumerable: true, get: function () { return asff_mapper_1.ASFFResults; } });
 __exportStar(require("./src/aws-config-mapper"), exports);
 __exportStar(require("./src/burpsuite-mapper"), exports);
 __exportStar(require("./src/converters-from-hdf/asff/reverse-asff-mapper"), exports);
 __exportStar(require("./src/converters-from-hdf/splunk/reverse-splunk-mapper"), exports);
 __exportStar(require("./src/dbprotect-mapper"), exports);
 __exportStar(require("./src/fortify-mapper"), exports);
+__exportStar(require("./src/ionchannel-mapper"), exports);
 __exportStar(require("./src/jfrog-xray-mapper"), exports);
 exports.AwsConfigMappingData = __importStar(require("./src/mappings/AwsConfigMappingData"));
 exports.CciNistMappingData = __importStar(require("./src/mappings/CciNistMappingData"));

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,oDAAkC;AAClC,0DAAwC;AACxC,yDAAuC;AACvC,qFAAmE;AACnE,yFAAuE;AACvE,yDAAuC;AACvC,uDAAqC;AACrC,0DAAwC;AACxC,4FAA4E;AAC5E,wFAAwE;AACxE,wFAAwE;AACxE,0GAA0F;AAC1F,4FAA4E;AAC5E,4FAA4E;AAC5E,sGAAsF;AACtF,sDAAoC;AACpC,0DAAwC;AACxC,qDAAmC;AACnC,sDAAoC;AACpC,qDAAmC;AACnC,0DAAwC;AACxC,oDAAkC;AAClC,yDAAuC;AACvC,sDAAoC;AACpC,6DAA2C;AAC3C,mDAAiC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6DAA0D;AAAlD,0GAAA,WAAW,OAAA;AACnB,0DAAwC;AACxC,yDAAuC;AACvC,qFAAmE;AACnE,yFAAuE;AACvE,yDAAuC;AACvC,uDAAqC;AACrC,0DAAwC;AACxC,0DAAwC;AACxC,4FAA4E;AAC5E,wFAAwE;AACxE,wFAAwE;AACxE,0GAA0F;AAC1F,4FAA4E;AAC5E,4FAA4E;AAC5E,sGAAsF;AACtF,sDAAoC;AACpC,0DAAwC;AACxC,qDAAmC;AACnC,sDAAoC;AACpC,qDAAmC;AACnC,0DAAwC;AACxC,oDAAkC;AAClC,yDAAuC;AACvC,sDAAoC;AACpC,6DAA2C;AAC3C,mDAAiC"}

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mitre/hdf-converters",
-    "version": "2.6.21",
+    "version": "2.6.24",
     "license": "Apache-2.0",
     "description": "Converter util library used to transform various scan results into HDF format",
     "files": [
@@ -26,12 +26,12 @@
         "@types/papaparse": "^5.3.2",
         "@types/xml2js": "^0.4.9",
         "aws-sdk": "^2.1046.0",
-        "axios": "^0.26.0",
+        "axios": "^0.27.2",
         "csv2json": "^2.0.2",
         "fast-xml-parser": "^3.21.1",
         "html-entities": "^2.3.2",
         "htmlparser2": "^7.1.2",
-        "inspecjs": "^2.6.17",
+        "inspecjs": "^2.6.24",
         "lodash": "^4.17.21",
         "moment": "^2.29.1",
         "papaparse": "^5.3.1",
@@ -41,7 +41,7 @@
     "devDependencies": {
         "@types/jest": "^27.0.0",
         "@types/lodash": "^4.14.161",
-        "@types/node": "^15.0.1",
+        "@types/node": "^17.0.25",
         "htmlparser2": "^7.1.2",
         "jest": "^27.0.6",
         "quicktype": "^15.0.260",

package/lib/src/asff-mapper/asff-mapper.d.ts

@@ -0,0 +1,106 @@
+import { ExecJSON } from 'inspecjs';
+import { BaseConverter } from '../base-converter';
+export declare enum SpecialCasing {
+    FirewallManager = "AWS Firewall Manager",
+    Prowler = "Prowler",
+    SecurityHub = "AWS Security Hub",
+    Trivy = "Aqua Trivy",
+    HDF2ASFF = "MITRE SAF HDF2ASFF",
+    Default = "Default"
+}
+export declare function consolidate(context: ASFFMapper, input: unknown[], file: Record<string, unknown>): ExecJSON.Control[];
+export declare class ASFFMapper extends BaseConverter {
+    meta: Record<string, string | undefined> | undefined;
+    supportingDocs: Map<SpecialCasing, Record<string, Record<string, unknown>>>;
+    defaultMappings: {
+        platform: {
+            name: string;
+            release: string;
+            target_id: {
+                transformer: (record: Record<string, unknown>) => string;
+            };
+        };
+        version: string;
+        statistics: {
+            duration: null;
+        };
+        profiles: {
+            name: {
+                transformer: () => string;
+            };
+            version: string;
+            title: {
+                transformer: () => string;
+            };
+            maintainer: null;
+            summary: string;
+            license: null;
+            copyright: null;
+            copyright_email: null;
+            supports: never[];
+            attributes: never[];
+            depends: never[];
+            groups: never[];
+            status: string;
+            controls: {
+                path: string;
+                key: string;
+                arrayTransformer: (input: unknown[], file: Record<string, unknown>) => ExecJSON.Control[];
+                id: {
+                    transformer: (finding: Record<string, unknown>) => string;
+                };
+                title: {
+                    transformer: (finding: Record<string, unknown>) => string;
+                };
+                desc: {
+                    path: string;
+                    transformer: (input: string) => string;
+                };
+                impact: {
+                    transformer: (finding: Record<string, unknown>) => number;
+                };
+                tags: {
+                    transformer: (finding: Record<string, unknown>) => Record<string, unknown> | undefined;
+                    nist: {
+                        transformer: (finding: Record<string, unknown>) => string[];
+                    };
+                };
+                descriptions: {
+                    data: {
+                        path: string;
+                        transformer: (input: Record<string, string>) => string;
+                    };
+                    label: string;
+                }[];
+                refs: {
+                    transformer: (finding: Record<string, unknown>) => Record<string, unknown>;
+                }[];
+                source_location: {};
+                code: string;
+                results: {
+                    status: {
+                        transformer: (finding: Record<string, unknown>) => ExecJSON.ControlResultStatus;
+                    };
+                    code_desc: {
+                        transformer: (finding: Record<string, unknown>) => string;
+                    };
+                    transformer: (finding: Record<string, unknown>) => Record<string, unknown>;
+                    start_time: {
+                        transformer: (finding: Record<string, unknown>) => string;
+                    };
+                }[];
+            }[];
+            sha256: string;
+        }[];
+    };
+    statusReason(finding: unknown): string | undefined;
+    setMappings(): void;
+    constructor(asff: Record<string, unknown>, supportingDocs: Map<SpecialCasing, Record<string, Record<string, unknown>>>, meta?: Record<string, string | undefined> | undefined);
+}
+export declare class ASFFResults {
+    data: Record<string, Record<string, unknown>[]>;
+    meta: Record<string, string | undefined> | undefined;
+    supportingDocs: Map<SpecialCasing, Record<string, Record<string, unknown>>>;
+    constructor(asffJson: string, securityhubStandardsJsonArray?: undefined | string[], meta?: Record<string, string | undefined> | undefined);
+    toHdf(): Record<string, ExecJSON.Execution>;
+}

package/lib/src/asff-mapper/asff-mapper.js

@@ -0,0 +1,462 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASFFResults = exports.ASFFMapper = exports.consolidate = exports.SpecialCasing = void 0;
+const html_entities_1 = require("html-entities");
+const inspecjs_1 = require("inspecjs");
+const lodash_1 = __importDefault(require("lodash"));
+const package_json_1 = require("../../package.json");
+const base_converter_1 = require("../base-converter");
+const global_1 = require("../utils/global");
+const case_firewall_manager_1 = require("./case-firewall-manager");
+const case_hdf2asff_1 = require("./case-hdf2asff");
+const case_prowler_1 = require("./case-prowler");
+const case_security_hub_1 = require("./case-security-hub");
+const case_trivy_1 = require("./case-trivy");
+const IMPACT_MAPPING = new Map([
+    ['CRITICAL', 0.9],
+    ['HIGH', 0.7],
+    ['MEDIUM', 0.5],
+    ['LOW', 0.3],
+    ['INFORMATIONAL', 0.0]
+]);
+const SEVERITY_LABEL = 'Severity.Label';
+const COMPLIANCE_STATUS = 'Compliance.Status';
+var SpecialCasing;
+(function (SpecialCasing) {
+    SpecialCasing["FirewallManager"] = "AWS Firewall Manager";
+    SpecialCasing["Prowler"] = "Prowler";
+    SpecialCasing["SecurityHub"] = "AWS Security Hub";
+    SpecialCasing["Trivy"] = "Aqua Trivy";
+    SpecialCasing["HDF2ASFF"] = "MITRE SAF HDF2ASFF";
+    SpecialCasing["Default"] = "Default";
+})(SpecialCasing = exports.SpecialCasing || (exports.SpecialCasing = {}));
+function whichSpecialCase(finding) {
+    const productArn = lodash_1.default.get(finding, 'ProductArn');
+    if (productArn.match(/^arn:[^:]+:securityhub:[^:]+:[^:]*:product\/aws\/firewall-manager$/)) {
+        return SpecialCasing.FirewallManager;
+    }
+    else if (productArn.match(/^arn:[^:]+:securityhub:[^:]+:[^:]*:product\/prowler\/prowler$/)) {
+        return SpecialCasing.Prowler;
+    }
+    else if (productArn.match(/^arn:[^:]+:securityhub:[^:]+:[^:]*:product\/aws\/securityhub$/)) {
+        return SpecialCasing.SecurityHub;
+    }
+    else if (productArn.match(/^arn:[^:]+:securityhub:[^:]+:[^:]*:product\/aquasecurity\/aquasecurity$/)) {
+        return SpecialCasing.Trivy;
+    }
+    else if (lodash_1.default.some(lodash_1.default.get(finding, 'FindingProviderFields.Types'), (type) => {
+        const version = type.split('/')[2].split('-')[0];
+        const [major, minor, patch] = version.split('.');
+        if (parseInt(major) > 1 &&
+            parseInt(minor) > 5 &&
+            parseInt(patch) > 20) {
+            return lodash_1.default.startsWith(type, 'MITRE/SAF/');
+        }
+        else {
+            return false;
+        }
+    })) {
+        return SpecialCasing.HDF2ASFF;
+    }
+    else {
+        return SpecialCasing.Default;
+    }
+}
+const SPECIAL_CASE_MAPPING = new Map([
+    [SpecialCasing.FirewallManager, (0, case_firewall_manager_1.getFirewallManager)()],
+    [SpecialCasing.Prowler, (0, case_prowler_1.getProwler)()],
+    [SpecialCasing.SecurityHub, (0, case_security_hub_1.getSecurityHub)()],
+    [SpecialCasing.Trivy, (0, case_trivy_1.getTrivy)()],
+    [SpecialCasing.HDF2ASFF, (0, case_hdf2asff_1.getHDF2ASFF)()]
+]);
+function externalProductHandler(context, product, data, func, defaultVal) {
+    var _a;
+    if (product !== SpecialCasing.Default &&
+        lodash_1.default.has(SPECIAL_CASE_MAPPING.get(product), func)) {
+        let keywords = {};
+        if (context.supportingDocs.has(product)) {
+            keywords = { ...context.supportingDocs.get(product) };
+        }
+        return (_a = lodash_1.default.get(SPECIAL_CASE_MAPPING.get(product), func)) === null || _a === void 0 ? void 0 : _a.apply(context, [
+            data,
+            keywords
+        ]);
+    }
+    else {
+        if (typeof defaultVal === 'function') {
+            return defaultVal();
+        }
+        else {
+            return defaultVal;
+        }
+    }
+}
+function handleIdGroup(context, idGroup) {
+    const [id, data] = idGroup;
+    const group = data.map((d) => d[0]);
+    const findings = data.map((d) => d[1]);
+    const productInfo = lodash_1.default.get(findings[0], 'ProductArn')
+        .split(':')
+        .slice(-1)[0]
+        .split('/');
+    const productName = externalProductHandler(context, whichSpecialCase(findings[0]), findings, 'productName', (0, html_entities_1.encode)(`${productInfo[1]}/${productInfo[2]}`));
+    const hasNoTitlePrefix = externalProductHandler(context, whichSpecialCase(findings[0]), null, 'doesNotHaveFindingTitlePrefix', false);
+    const titlePrefix = hasNoTitlePrefix ? '' : `${productName}: `;
+    const waiverData = externalProductHandler(context, whichSpecialCase(findings[0]), group, 'waiverData', {});
+    return {
+        id: id,
+        title: `${titlePrefix}${lodash_1.default.uniq(group.map((d) => d.title)).join(';')}`,
+        tags: lodash_1.default.mergeWith({}, ...group.map((d) => d.tags), (acc, cur) => {
+            if (acc === undefined || cur === undefined) {
+                return acc || cur;
+            }
+            else {
+                return Array.isArray(acc) || Array.isArray(cur)
+                    ? lodash_1.default.uniq(lodash_1.default.concat([], acc, cur))
+                    : acc;
+            }
+        }),
+        impact: Math.max(...group.map((d) => d.impact)),
+        desc: externalProductHandler(context, whichSpecialCase(findings[0]), group, 'desc', lodash_1.default.uniq(group.map((d) => d.desc)).join('\n')),
+        descriptions: group
+            .map((d) => d.descriptions)
+            .flat()
+            .filter((element, index, arr) => element &&
+            element.data !== '' &&
+            index ===
+                arr.findIndex((e) => e !== null && e !== undefined && e.data === element.data)),
+        refs: group
+            .map((d) => d.refs)
+            .flat()
+            .filter((element) => lodash_1.default.get(element, 'url') !== undefined),
+        source_location: (() => {
+            const locs = lodash_1.default.uniq(group.map((d) => d.source_location)).filter((loc) => Object.keys(loc || {}).length !== 0);
+            if (locs.length === 0) {
+                return {};
+            }
+            else if (locs.length === 1) {
+                return locs[0];
+            }
+            else {
+                return { ref: JSON.stringify(locs) };
+            }
+        })(),
+        ...(Object.keys(waiverData || {}).length !== 0 && {
+            waiver_data: waiverData
+        }),
+        code: externalProductHandler(context, whichSpecialCase(findings[0]), group, 'code', JSON.stringify({ Findings: findings }, null, 2)),
+        results: group.map((d) => d.results).flat()
+    };
+}
+function consolidate(context, input, file) {
+    const allFindings = lodash_1.default.get(file, 'Findings');
+    if (input.length !== allFindings.length) {
+        throw new Error('The number of generated controls should be the same as the number of findings while consolidating.');
+    }
+    const idGroups = lodash_1.default.groupBy(lodash_1.default.zip(input, allFindings), (value) => {
+        const [hdfControl, asffFinding] = value;
+        return externalProductHandler(context, whichSpecialCase(asffFinding), asffFinding, 'subfindingsId', lodash_1.default.get(hdfControl, 'id'));
+    });
+    return Object.entries(idGroups || {}).map((idGroup) => handleIdGroup(context, idGroup));
+}
+exports.consolidate = consolidate;
+function wrapWithFindingsObject(output) {
+    if (!lodash_1.default.has(output, 'Findings')) {
+        if (Array.isArray(output)) {
+            output = { Findings: output };
+        }
+        else {
+            output = { Findings: [output] };
+        }
+    }
+    return output;
+}
+function fixFileInput(asffJson) {
+    let output = {};
+    try {
+        output = JSON.parse(asffJson);
+    }
+    catch {
+        const fixedInput = `[${asffJson
+            .trim()
+            .replace(/}\n/g, '},\n')
+            .replace(/\},\n\$/g, '')}]`;
+        output = JSON.parse(fixedInput);
+    }
+    return wrapWithFindingsObject(output);
+}
+class ASFFMapper extends base_converter_1.BaseConverter {
+    constructor(asff, supportingDocs, meta = undefined) {
+        super(asff);
+        this.defaultMappings = {
+            platform: {
+                name: 'Heimdall Tools',
+                release: package_json_1.version,
+                target_id: {
+                    transformer: (record) => {
+                        const productInfo = lodash_1.default.get(record, 'Findings[0].ProductArn')
+                            .split(':')
+                            .slice(-1)[0]
+                            .split('/');
+                        const defaultTargetId = `${productInfo[1]} | ${productInfo[2]}`;
+                        return externalProductHandler(this, whichSpecialCase(lodash_1.default.get(record, 'Findings[0]')), [lodash_1.default.get(record, 'Findings[0]'), record.Findings], 'productName', (0, html_entities_1.encode)(defaultTargetId));
+                    }
+                }
+            },
+            version: package_json_1.version,
+            statistics: {
+                duration: null
+            },
+            profiles: [
+                {
+                    name: {
+                        transformer: () => {
+                            var _a;
+                            return ((_a = this.meta) === null || _a === void 0 ? void 0 : _a.name) || 'AWS Security Finding Format';
+                        }
+                    },
+                    version: '',
+                    title: {
+                        transformer: () => {
+                            return lodash_1.default.get(this.meta, 'title') || 'ASFF Findings';
+                        }
+                    },
+                    maintainer: null,
+                    summary: '',
+                    license: null,
+                    copyright: null,
+                    copyright_email: null,
+                    supports: [],
+                    attributes: [],
+                    depends: [],
+                    groups: [],
+                    status: 'loaded',
+                    controls: [
+                        {
+                            path: 'Findings',
+                            key: 'id',
+                            arrayTransformer: consolidate.bind(this, this),
+                            id: {
+                                transformer: (finding) => externalProductHandler(this, whichSpecialCase(finding), finding, 'findingId', (0, html_entities_1.encode)(lodash_1.default.get(finding, 'GeneratorId')))
+                            },
+                            title: {
+                                transformer: (finding) => externalProductHandler(this, whichSpecialCase(finding), finding, 'findingTitle', (0, html_entities_1.encode)(lodash_1.default.get(finding, 'Title')))
+                            },
+                            desc: {
+                                path: 'Description',
+                                transformer: (input) => (0, html_entities_1.encode)(input)
+                            },
+                            impact: {
+                                transformer: (finding) => {
+                                    let impact;
+                                    if (lodash_1.default.get(finding, 'Workflow.Status') === 'SUPPRESSED') {
+                                        impact = 'INFORMATIONAL';
+                                    }
+                                    else {
+                                        const defaultFunc = () => lodash_1.default.get(finding, SEVERITY_LABEL)
+                                            ? lodash_1.default.get(finding, SEVERITY_LABEL)
+                                            : lodash_1.default.get(finding, 'Severity.Normalized') /
+                                                100.0;
+                                        impact = externalProductHandler(this, whichSpecialCase(finding), finding, 'findingImpact', defaultFunc);
+                                    }
+                                    return typeof impact === 'string'
+                                        ? IMPACT_MAPPING.get(impact) || 0
+                                        : impact;
+                                }
+                            },
+                            tags: {
+                                transformer: (finding) => externalProductHandler(this, whichSpecialCase(finding), finding, 'findingTags', {}),
+                                nist: {
+                                    transformer: (finding) => {
+                                        const tags = externalProductHandler(this, whichSpecialCase(finding), finding, 'findingNistTag', []);
+                                        if (tags.length === 0) {
+                                            return global_1.DEFAULT_STATIC_CODE_ANALYSIS_NIST_TAGS;
+                                        }
+                                        else {
+                                            return tags;
+                                        }
+                                    }
+                                }
+                            },
+                            descriptions: [
+                                {
+                                    data: {
+                                        path: 'Remediation.Recommendation',
+                                        transformer: (input) => {
+                                            const data = [];
+                                            if (lodash_1.default.has(input, 'Text')) {
+                                                data.push(lodash_1.default.get(input, 'Text'));
+                                            }
+                                            if (lodash_1.default.has(input, 'Url')) {
+                                                data.push(lodash_1.default.get(input, 'Url'));
+                                            }
+                                            return data.join('\n');
+                                        }
+                                    },
+                                    label: 'fix'
+                                }
+                            ],
+                            refs: [
+                                {
+                                    transformer: (finding) => {
+                                        return {
+                                            ...(lodash_1.default.has(finding, 'SourceUrl') && {
+                                                url: {
+                                                    path: 'SourceUrl'
+                                                }
+                                            })
+                                        };
+                                    }
+                                }
+                            ],
+                            source_location: {},
+                            code: '',
+                            results: [
+                                {
+                                    status: {
+                                        transformer: (finding) => {
+                                            const defaultFunc = () => {
+                                                if (lodash_1.default.has(finding, COMPLIANCE_STATUS)) {
+                                                    switch (lodash_1.default.get(finding, COMPLIANCE_STATUS)) {
+                                                        case 'PASSED':
+                                                            return inspecjs_1.ExecJSON.ControlResultStatus.Passed;
+                                                        case 'WARNING':
+                                                            return inspecjs_1.ExecJSON.ControlResultStatus.Skipped;
+                                                        case 'FAILED':
+                                                            return inspecjs_1.ExecJSON.ControlResultStatus.Failed;
+                                                        case 'NOT_AVAILABLE':
+                                                            return inspecjs_1.ExecJSON.ControlResultStatus.Skipped;
+                                                        default:
+                                                            return inspecjs_1.ExecJSON.ControlResultStatus.Error;
+                                                    }
+                                                }
+                                                else {
+                                                    return inspecjs_1.ExecJSON.ControlResultStatus.Skipped;
+                                                }
+                                            };
+                                            return externalProductHandler(this, whichSpecialCase(finding), finding, 'subfindingsStatus', defaultFunc);
+                                        }
+                                    },
+                                    code_desc: {
+                                        transformer: (finding) => {
+                                            let output = externalProductHandler(this, whichSpecialCase(finding), finding, 'subfindingsCodeDesc', '');
+                                            if (output) {
+                                                output += '; ';
+                                            }
+                                            const resources = lodash_1.default.get(finding, 'Resources')
+                                                .map((resource) => {
+                                                let hash = `Type: ${(0, html_entities_1.encode)(lodash_1.default.get(resource, 'Type'))}, Id: ${(0, html_entities_1.encode)(lodash_1.default.get(resource, 'Id'))}`;
+                                                if (lodash_1.default.has(resource, 'Partition')) {
+                                                    hash += `, Partition: ${(0, html_entities_1.encode)(lodash_1.default.get(resource, 'Partition'))}`;
+                                                }
+                                                if (lodash_1.default.has(resource, 'Region')) {
+                                                    hash += `, Region: ${(0, html_entities_1.encode)(lodash_1.default.get(resource, 'Region'))}`;
+                                                }
+                                                return hash;
+                                            })
+                                                .join(', ');
+                                            output += `Resources: [${resources}]`;
+                                            return output;
+                                        }
+                                    },
+                                    transformer: (finding) => {
+                                        const message = (() => {
+                                            const defaultFunc = () => {
+                                                const statusReason = this.statusReason(finding);
+                                                switch (lodash_1.default.get(finding, COMPLIANCE_STATUS)) {
+                                                    case undefined:
+                                                        return undefined;
+                                                    case 'PASSED':
+                                                        return statusReason;
+                                                    case 'WARNING':
+                                                        return undefined;
+                                                    case 'FAILED':
+                                                        return statusReason;
+                                                    case 'NOT_AVAILABLE':
+                                                        return undefined;
+                                                    default:
+                                                        return statusReason;
+                                                }
+                                            };
+                                            return externalProductHandler(this, whichSpecialCase(finding), finding, 'subfindingsMessage', defaultFunc);
+                                        })();
+                                        const skipMessage = (() => {
+                                            const statusReason = this.statusReason(finding);
+                                            switch (lodash_1.default.get(finding, COMPLIANCE_STATUS)) {
+                                                case undefined:
+                                                    return statusReason;
+                                                case 'PASSED':
+                                                    return undefined;
+                                                case 'WARNING':
+                                                    return statusReason;
+                                                case 'FAILED':
+                                                    return undefined;
+                                                case 'NOT_AVAILABLE':
+                                                    return statusReason;
+                                                default:
+                                                    return undefined;
+                                            }
+                                        })();
+                                        return {
+                                            ...(message !== undefined && { message }),
+                                            ...(skipMessage !== undefined && {
+                                                skip_message: skipMessage
+                                            })
+                                        };
+                                    },
+                                    start_time: {
+                                        transformer: (finding) => lodash_1.default.get(finding, 'LastObservedAt') ||
+                                            lodash_1.default.get(finding, 'UpdatedAt')
+                                    }
+                                }
+                            ]
+                        }
+                    ],
+                    sha256: ''
+                }
+            ]
+        };
+        this.meta = meta;
+        this.supportingDocs = supportingDocs;
+        this.setMappings();
+    }
+    statusReason(finding) {
+        var _a;
+        return (_a = lodash_1.default.get(finding, 'Compliance.StatusReasons')) === null || _a === void 0 ? void 0 : _a.map((reason) => Object.entries(reason || {}).map(([key, value]) => {
+            return `${(0, html_entities_1.encode)(key)}: ${(0, html_entities_1.encode)(value)}`;
+        })).flat().join('\n');
+    }
+    setMappings() {
+        this.mappings = externalProductHandler(this, whichSpecialCase(lodash_1.default.get(this.data, 'Findings[0]')), this, 'mapping', this.defaultMappings);
+    }
+}
+exports.ASFFMapper = ASFFMapper;
+class ASFFResults {
+    constructor(asffJson, securityhubStandardsJsonArray = undefined, meta = undefined) {
+        this.meta = meta;
+        this.supportingDocs = new Map();
+        this.supportingDocs.set(SpecialCasing.SecurityHub, lodash_1.default.get(SPECIAL_CASE_MAPPING.get(SpecialCasing.SecurityHub), 'securityhubSupportingDocs', (standards) => {
+            throw new Error(`supportingDocs function should've been defined: ${standards}`);
+        })(securityhubStandardsJsonArray));
+        const findings = lodash_1.default.get(fixFileInput(asffJson), 'Findings');
+        this.data = lodash_1.default.groupBy(findings, (finding) => {
+            const productInfo = lodash_1.default.get(finding, 'ProductArn')
+                .split(':')
+                .slice(-1)[0]
+                .split('/');
+            const defaultFilename = `${productInfo[1]} | ${productInfo[2]}.json`;
+            return externalProductHandler(this, whichSpecialCase(finding), [finding, findings], 'filename', (0, html_entities_1.encode)(defaultFilename));
+        });
+    }
+    toHdf() {
+        return lodash_1.default.mapValues(this.data, (val) => {
+            const wrapped = wrapWithFindingsObject(val);
+            return new ASFFMapper(externalProductHandler(this, whichSpecialCase(lodash_1.default.get(wrapped, 'Findings[0]')), wrapped, 'preprocessingASFF', wrapped), externalProductHandler(this, whichSpecialCase(lodash_1.default.get(wrapped, 'Findings[0]')), [wrapped, this.supportingDocs], 'supportingDocs', this.supportingDocs), externalProductHandler(this, whichSpecialCase(lodash_1.default.get(wrapped, 'Findings[0]')), undefined, 'meta', this.meta)).toHdf();
+        });
+    }
+}
+exports.ASFFResults = ASFFResults;
+//# sourceMappingURL=asff-mapper.js.map