@newrelic/security-agent 0.0.1

package/lib/nr-security-agent/lib/core/sec-agent-constants.js

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict';
+
+const AWS_LAMBDA_NODE_EXEC_ENV_IDENTIFIER = /^AWS_Lambda_nodejs.*$/g;
+const AWS_EXECUTION_ENV_VAR = 'AWS_EXECUTION_ENV';
+const path = require('path');
+const API = require('../../../nr-security-api');
+const NRAgent = API.getNRAgent();
+
+let CSEC_HOME = NRAgent &&  NRAgent.config.newrelic_home ? NRAgent.config.newrelic_home  : require('path').join(process.cwd());
+const CSEC_GROUP_NAME = NRAgent ? NRAgent.config.security.mode : 'IAST';
+CSEC_HOME = path.resolve(CSEC_HOME);
+const agentStartTime = new Date().toString();
+
+module.exports = {
+    CSEC_HOME: CSEC_HOME,
+    CSEC_GROUP_NAME: CSEC_GROUP_NAME,
+    LOG_DIR: `${CSEC_HOME}/nr-security-home/logs/`,
+    CSEC_HOME_TMP: `${CSEC_HOME}/nr-security-home/tmp/language-agent/${process.env.applicationUUID}`,
+    AGENT_START_TIME: agentStartTime,
+    FRAMEWORK: '',
+    STATUS_LOG_FILE: `${CSEC_HOME}/nr-security-home/logs/snapshots/node-security-collector-status-${process.env.applicationUUID}.log`,
+
+    DB_LIST: {
+        MYSQL: 'MYSQL',
+        MYSQL2: 'MYSQL',
+        POSTGRES: 'POSTGRES',
+        MONGODB: 'MONGODB',
+        ORACLEDB: 'ORACLEDB',
+        MSSQL: 'MSSQL',
+        SQLITE3: 'SQLITE3'
+    },
+    SERVER_COMMAND: {
+        SET_LOG_LEVEL: 0,
+        SHUTDOWN_LANGUAGE_AGENT: 1,
+        SET_DEFAULT_LOG_LEVEL: 2,
+        ENABLE_HTTP_REQUEST_PRINTING: 3,
+        UPLOAD_LOGS: 4,
+        UNSUPPORTED_AGENT: 5,
+        VALIDATION_RESPONSE: 6,
+        START_VULNERABILITY_SCAN: 8,
+        STARTUP_WELCOME_MSG: 10,
+        FUZZ_REQUEST: 11,
+        COLLECTOR_CONFIG: 100,
+        BLOCKING: 101,
+        POLICY_ERROR: 102,
+        OBEY_WS_RECONNECT:12
+
+    },
+    JSON_NAME: {
+        EVENT: 'Event',
+        HC: 'LAhealthcheck',
+        SD: 'Shutdown',
+        APP_INFO: 'ApplicationInfo',
+        ICC: 'IntCodeControlCommand',
+        CONNSTAT: 'http-connection-stat'
+    },
+    COLLECTOR_TYPE: 'NODE',
+    LANGUAGE: 'JavaScript',
+    AWS_LAMBDA_QUALIFIED_ARN_ENV_IDENTIFIER: 'AWS_LAMBDA_ARN',
+    AWS_LAMBDA_FUNCTION_NAME_ENV_IDENTIFIER: 'AWS_LAMBDA_FUNCTION_NAME',
+    AWS_LAMBDA_FUNCTION_VERSION_ENV_IDENTIFIER: 'AWS_LAMBDA_FUNCTION_VERSION',
+    AWS_SESSION_TOKEN_ENV_IDENTIFIER: 'AWS_SESSION_TOKEN',
+    LAMBDA_TASK_ROOT_ENV_IDENTIFIER: 'LAMBDA_TASK_ROOT',
+    LAMBDA_ENABLE_RESPONSE_BLOCKING: 'LAMBDA_ENABLE_RESPONSE_BLOCKING',
+    AWS_LAMBDA_NODE_EXEC_ENV_IDENTIFIER,
+    AWS_EXECUTION_ENV_VAR,
+    IS_LAMBDA_ENV: Array.isArray(
+        (process.env[AWS_EXECUTION_ENV_VAR] || '').match(AWS_LAMBDA_NODE_EXEC_ENV_IDENTIFIER)
+    ),
+    LAMBDA_RUNTIME_DIR_VAR: 'LAMBDA_RUNTIME_DIR',
+    CSEC_LAST_FUZZ_REQUEST_TIME: 'CSEC_LAST_FUZZ_REQUEST_TIME',
+    NR_CSEC_FUZZ_REQUEST_ID: 'nr-csec-fuzz-request-id',
+    EMPTY_APPLICATION_UUID: '--0--',
+    QUESTIONMARK: '?',
+    PIPE_SEP: '|',
+    ATTHERATE: '@',
+    EMPTY_STR: '',
+    COLON: ':',
+    OPEN_PARANTHESIS: '(',
+    CLOSE_PARANTHESIS: ')',
+    SLASH: '/',
+    INCOMING_MSG: 'IncomingMessage',
+    OBJECT: 'object',
+    STRING: 'string',
+    TRIGGER_VIA_RCI: 'triggerViaRCI',
+    RCI_METHOD_CALLS: 'rciMethodsCalls',
+    VULNERABLE: 'VULNERABLE',
+    UTF8: 'utf8',
+    CONTENT_TYPE: 'content-type',
+    TEXT_HTML: 'text/html',
+    APPLICATION_JSON: 'application/json',
+    APPLICATION_XML: 'application/xml',
+    APPLICATION_XHTML: 'application/xhtml+xml',
+    TEXT_PLAIN: 'text/plain',
+    APPLICATION_X_FORM_URLENCODED: 'application/x-www-form-urlencoded',
+    MULTIPART_FORM_DATA: 'multipart/form-data',
+    XFORFOR: 'x-forwarded-for',
+    DOUBLE_DOLLAR: '$$',
+    LOADING_MODULE: 'Loading module ',
+    EXITEVENT: 'exit-event',
+
+    LOG_MESSAGES: {
+        LOADED_CSEC_ENVS_MSG: '[STEP-1][COMPLETE][env] Environment Information Gathering Done.',
+        COLLECTOR_INFO: ' CSEC Node version : %s , json version : %s and build number : %s',
+        APP_INFO_GATHERING_STARTED: '[STEP-1][BEGIN][APP_INFO] Gathering Application Info For Current Process.',
+        DEP_APP_GATHERING_STARTED: '[BEGIN][APP_INFO][DEPLOYED_APP] Gathering deployed application info for current process',
+        APP_INFO_DEP_APP: '[APP_INFO][DEPLOYED_APP] Deployed application info generated :%s',
+        AGENT_INIT_SUCCESSFUL: '[STEP-3][protection][BEGIN] Node CSEC Agent Attached To Process: PID = %s, With Generated Applicationuid = %s By Static Attachment',
+        AGENT_INIT_SUCCESSFUL_COMPLETE: '[STEP-3][PROTECTION][COMPLETE] Protecting new process with PID = %s and UUID = %s',
+        AGENT_INIT_FAILED: '[protection] Coudn\'t Initiate CSEC Agent For Process: : Pid = {pid}, With Generated Applicationuid = {application_uuid}.',
+        LOG_FILE_INITIATED_MSG: 'Init Log File Initiated.',
+        LOG_CONFIGURED_SUCCESSFULLY_MSG: 'Init Logger Configured Successfully With Level: %s And Rollover On Max Size %s.',
+        INIT_APPINFO_SEND: '[STEP-9][COMPLETE][APP_INFO][DEPLOYED_APP] Updated ApplicationInfo Will Be Sent To Prevent-web Service',
+        AGENT_ATTACH_FAIL: 'CSEC_GROUP_NAME Environment Not Present, Agent Attachment Failed',
+        APP_INFO_GENERATED: '[APP_INFO] Application Info Generated: %s ',
+        SCHED_SERVICE_START: '[STEP-5][BEGIN][MODULE] Start Threads/pools/scheduler',
+        SCHED_SERVICE_START_BEG: '[BEGIN][MODULE] Started Threads/pools/scheduler',
+        START_HC: '[BEGIN][MODULE] Starting Healthcheck',
+        START_IOM: '[BEGIN][MODULE] Starting Inboundoutboundmonitor.',
+        END_HC: '[COMPLETE][MODULE] Started Healthcheck',
+        END_IOM: '[COMPLETE][MODULE] Started Inboundoutboundmonitor.',
+        START_DIR_WATCH: '[BEGIN][MODULE] Starting DirectoryWatcher',
+        STARTED_DIR_WATCH: '[COMPLETE][MODULE] Started DirectoryWatcher',
+        NODE_VERSION_MSG: 'Node Version Is %s, Starting Websocket Client In Parent Process',
+        NODE_VERSION_MSG_WORKER: 'Node Version Is %s, Starting Websocket Client In Worker Thread',
+        MSG_FROM_WORKKER: 'Message From Worker Thread:',
+        RECV_POL_DATA: '[STEP-7][BEGIN][POLICY] Received Policy Data From Prevent-web Service:%s',
+        RECV_GLOBAL_POL_DATA: 'Received Global Policy Parameters From Prevent-web Service:%s',
+        EXP_RAISE_GLOBAL_POL: 'Exception Raised In Global Policy Validation:',
+        UNABLE_TO_WRITE_TO_POL_FILE: 'Unable To Write To Policy Yaml File',
+        POL_UPDATE_SUCCESS: 'Policy Updated To File Successfully',
+        CHANGE_DETECT_POL_FILE: 'Changes Detected In Policy File',
+        ERROR_READ_FROM_POL_FILE: 'ERROR In Reading Policy From File',
+        POL_UPDATE_RESP: 'Policy Update Response Is:',
+        UPDATE_POL_SENT_SERVER: 'Updated Policy Sent To Prevent Web',
+        EXP_RAISE_POL: 'Exception Raised In Policy Validation:',
+        FALLBACK_TO_CURR_POLICY: 'Fallback To Current Policy!!!:%s',
+        POLICY_APPLIED: '[STEP-7][COMPLETE][POLICY] Policy Applied :',
+        POL_PULL_INT_IS: 'Policy Pull Interval Is:',
+        LOG_LEVEL_UPDATED: 'Log Level Updated To:',
+        DEFAULT_POL_SET: 'Default Policy Has Been Set :',
+        UNABLE_SET_DEFAULT_POL: 'Unable To Set Default Policy',
+        COLLECTOR_INIT_WITH_PROP: 'Collector Is Initialized With Properties:',
+        PARSING_EXP_WELCOME_MSG: 'Parsing Exeception In Startup Welcome Command',
+        ACCESS_BLOCKED_IP_DETECTED: 'Access By Blocked Ip Address Detected : ',
+        FIRST_EVENT_INTERCEPTED: '[BEGIN][EVENT] First event intercepted',
+        FIRST_EVENT_PROCESSED: '[EVENT] First event processed :',
+        FIRST_EVENT_SENT: '[STEP-8][COMPLETE][EVENT] First Event Sent For Validation',
+        DETECTED_BROKEN_CONN: 'Detected Broken Connection. Will Reconnect Now!',
+        MAX_WS_RETRY: 'Maximum WS Retry Limit Reached. Unable To Connect To Prevent Web Service!!!',
+        EVENT_SENT: 'Event Sent:: ',
+        ERROR_WHILE_SEND_EVENT: 'ERROR While Sending Event: {}',
+        WS_CONNECTED: '[STEP-4][COMPLETE][WS] Connected To Prevent-web Service',
+        SENDING_APPINFO: '[APP_INFO] Sending Application Info To Prevent-web Service: ',
+        SENDING_APPINFO_COMPLETE: '[COMPLETE][APP_INFO] Application info sent to Prevent-Web service : {}',
+        APPLY_INSTRUMENTATION: '[STEP-6][BEGIN][instrumentation] Applying Instrumentation',
+        AVAIL_DISK: 'Available Disk Space Is: ',
+        AVAIL_DISK_ERROR: 'Insufficient Disk Space Available To The Location %s Is : %s',
+        OBJ_WRAP_MUST_BE_FUNC: 'original object and wrapper must be functions',
+        NO_ORIG_FUNC_TO_WRAP: 'no original function %s to wrap',
+        NO_WRAPPER_FUNC: 'no wrapper function',
+        ERR_IN_INIT_HOOK: 'Error in initial setup of hook',
+        ERR_IN_ONSTART: 'Error in execution onStart Hook',
+        ERR_IN_ONFINISH: 'Error in execution onFinish Hook',
+        COLLECTOR_SHUT_DOWN: 'Collector Is Shutting Down!!!!'
+
+    }
+};

package/lib/nr-security-agent/lib/core/sec-util.js

@@ -0,0 +1,166 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict';
+
+const { SecEvent } = require('./event');
+const logs = require('./logging');
+const { Agent } = require('./agent');
+const shaUtil = require('./sha-size-util');
+const { LOG_MESSAGES, NR_CSEC_FUZZ_REQUEST_ID, COLON, VULNERABLE, EXITEVENT, EMPTY_STR } = require('./sec-agent-constants');
+const API = require('../../../nr-security-api');
+const NRAgent = API.getNRAgent();
+
+const statusUtils = require('./statusUtils');
+
+let firstEvent = false;
+let firstEventSent = false;
+
+const events = require('events');
+const eventEmitter = undefined;
+
+let logger = logs.getLogger();
+const initLogger = logs.getInitLogger();
+
+const NODE_SER = 'node-serialize/lib/serialize.js';
+
+function getSecEventEmitter() {
+    if (eventEmitter) {
+        return eventEmitter;
+    } else {
+        return new events.EventEmitter();
+    }
+}
+
+
+/**
+ * Sets the logger instance.
+ *
+ * @param {*} loggerInstance
+ */
+const setLogger = loggerInstance => {
+    logger = loggerInstance;
+};
+
+
+function promisify(thisArg, fn) {
+    return (...args) => new Promise((resolve, reject) => {
+        args.push((err, data) => {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(data);
+            }
+        });
+        fn.apply(thisArg, args);
+    });
+}
+
+const sleep = (timeout) => new Promise((resolve) => {
+    setTimeout(resolve, timeout);
+});
+
+
+function generateSecEvent(securityMetadata) {
+    const traceObject = securityMetadata.traceObject;
+    const request = securityMetadata.request;
+
+    try {
+        let stakTrace = traceObject.stacktrace;
+        let uri = EMPTY_STR;
+        if (request.uri) {
+            uri += request.uri;
+        }
+
+        let apiId = shaUtil.getSHA256ForData(traceObject.stacktrace.join('|') + uri);
+        const agentModule = Agent.getAgent();
+        const metaData = {};
+        if (traceObject.sourceDetails && traceObject.sourceDetails.evalObj) {
+            metaData.triggerViaRCI = true;
+            metaData.rciMethodsCalls = traceObject.sourceDetails.evalObj.invokedCalls;
+            metaData.rciDetail = traceObject.sourceDetails.evalObj;
+            if (traceObject.sourceDetails.evalObj) {
+                const evalFile = traceObject.sourceDetails.evalObj.fileName;
+                if (evalFile && evalFile.includes(NODE_SER)) {
+                    metaData.triggerViaDeserialisation = true;
+                }
+            }
+        }
+        const isClientDetectedFromXFF = false;
+
+        if (!firstEvent) {
+            initLogger.info(LOG_MESSAGES.FIRST_EVENT_INTERCEPTED, securityMetadata.eventCategory, JSON.stringify(request));
+        }
+        const isAPIBlocked = false;
+
+        const event = new SecEvent(traceObject.sourceDetails.fileName, traceObject.sourceDetails.funcName, traceObject.sourceDetails.lineNumber, securityMetadata.interceptedArgs, securityMetadata.executionId, agentModule.applicationInfo, securityMetadata.request, securityMetadata.eventType, traceObject.sourceDetails.source, securityMetadata.eventCategory, metaData, stakTrace, apiId, isAPIBlocked);
+        event.metaData.isClientDetectedFromXFF = isClientDetectedFromXFF;
+
+        if (!firstEvent) {
+            initLogger.info(LOG_MESSAGES.FIRST_EVENT_PROCESSED, JSON.stringify(event));
+            firstEvent = true;
+        }
+
+        return event;
+    } catch (e) {
+        statusUtils.addErrortoBuffer(e);
+        logger.error("Error in generating event:", e);
+    }
+
+}
+
+/**
+ *
+ * @param {current context} context
+ * @param {Sec agent module} agentModule
+ * Utility to generate exit events.
+ */
+function generateExitEvent(secEvent) {
+    if (secEvent && secEvent.httpRequest && secEvent.httpRequest.headers[NR_CSEC_FUZZ_REQUEST_ID]) {
+        try {
+            const fuzzHeader = secEvent.httpRequest.headers[NR_CSEC_FUZZ_REQUEST_ID];
+            const apiId = fuzzHeader.split(COLON)[0].trim();
+            if (fuzzHeader.includes(VULNERABLE) && apiId === secEvent.apiId) {
+                const exitEvent = {};
+                exitEvent.jsonName = EXITEVENT;
+                exitEvent.applicationUUID = secEvent.applicationUUID;
+                exitEvent.groupName = secEvent.groupName;
+                exitEvent.nodeId = secEvent.nodeId;
+                exitEvent.jsonVersion = secEvent.jsonVersion;
+                exitEvent.buildNumber = secEvent.buildNumber;
+                exitEvent.policyVersion = secEvent.policyVersion;
+                exitEvent.executionId = secEvent.id;
+                exitEvent.caseType = secEvent.caseType;
+                exitEvent.k2RequestIdentifier = secEvent.httpRequest.headers[NR_CSEC_FUZZ_REQUEST_ID];
+                sendEvent(exitEvent);
+            }
+        } catch (error) {
+            logger.error('Error in generating exit event', error);
+        }
+    }
+}
+
+
+function sendEvent(secEvent) {
+    const agentModule = Agent.getAgent();
+    if (agentModule.status.getStatus() === 'active' && NRAgent.config.security.enabled) {
+        agentModule.client.dispatcher(secEvent);
+        if (!firstEventSent) {
+            initLogger.info(LOG_MESSAGES.FIRST_EVENT_SENT, JSON.stringify(secEvent));
+            firstEventSent = true;
+        }
+    }
+
+}
+
+module.exports = {
+    setLogger,
+    getSecEventEmitter: getSecEventEmitter,
+    promisify,
+    sleep,
+    generateSecEvent,
+    sendEvent,
+    generateExitEvent
+};

package/lib/nr-security-agent/lib/core/sha-size-util.js

@@ -0,0 +1,338 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const hash = require('hash.js');
+const path = require('path');
+const async_hooks = require('async_hooks');
+
+const INCLUDED_FILE_EXT_REGEX = /(\.)(js|ts|ejs|html|properties|yml|yaml|json|hbs)$/;
+const TWO_PIPES = '||';
+const HEX_DIGEST = 'hex';
+const thresh = 1024;
+const units = ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+
+let logger;
+let CurrentPromise = global.Promise;
+
+module.exports = { getApplicationSHAAndSize, getApplicationSHAAndSizeSync, getSHA256ForFile, getSHA256ForFileSync, setPromise, setLogger, getSHA256ForData };
+
+/**
+ * This is a utility which is used to calculate
+ * sha256 for the complete application context.
+ */
+async function getApplicationSHAAndSize (appPath) {
+    if (CurrentPromise) {
+        try {
+            const shaMap = new Map();
+            const shaAndSizeObj = await getSHA256AndSizeForPath(appPath, shaMap);
+            return {
+                sha256: getSHA256ForData(shaAndSizeObj.shaList.join(TWO_PIPES)),
+                size: getHumanReadableSize(shaAndSizeObj.sizeList.reduce((result, value) => {
+                    return result + value;
+                }, 0)),
+                shaMap: shaMap
+            };
+        } catch (err) {
+            logger.error('Error while calculating SHA and size for application!');
+            logger.debug(err);
+            return {};
+        }
+    } else {
+        logger.debug('Promise haven\'t been set!');
+        return {};
+    }
+}
+
+function getApplicationSHAAndSizeSync (appPath, skipRegex = null) {
+    try {
+        const shaMap = new Map();
+        const shaAndSizeObj = getSHA256AndSizeForPathSync(appPath, shaMap, skipRegex);
+        return {
+            sha256: getSHA256ForData(shaAndSizeObj.shaList.join(TWO_PIPES)),
+            size: getHumanReadableSize(shaAndSizeObj.sizeList.reduce((result, value) => {
+                return result + value;
+            }, 0)),
+            shaMap: shaMap
+        };
+    } catch (err) {
+        logger.error('Error while calculating SHA and size for application!');
+        logger.debug(err);
+        return {};
+    }
+}
+
+/**
+ * Gets sha256 and Size for all the elements of
+ * given filePath.
+ *
+ * @param {String} filePath
+ */
+async function getSHA256AndSizeForPath (filePath, shaMap) {
+    const pathStatObject = {};
+    pathStatObject.shaList = [];
+    pathStatObject.sizeList = [];
+    try {
+        const stats = await getStats(filePath);
+        if (stats.isDirectory()) {
+            const fileList = await getSortedDirContent(filePath);
+            if (fileList) {
+                for (const file of fileList) {
+                    const calledStateObject = await getSHA256AndSizeForPath(file, shaMap);
+                    pathStatObject.shaList = pathStatObject.shaList.concat(calledStateObject.shaList);
+                    pathStatObject.sizeList = pathStatObject.sizeList.concat(calledStateObject.sizeList);
+                }
+            }
+        } else if (filePath.match(INCLUDED_FILE_EXT_REGEX)) {
+            const sha = await getSHA256ForFile(filePath);
+            const fileSizeInBytes = stats.size;
+            if (sha && sha !== null) {
+                pathStatObject.shaList.push(sha);
+                if (fileSizeInBytes) {
+                    pathStatObject.sizeList.push(fileSizeInBytes);
+                }
+            }
+        }
+    } catch (err) {
+        logger.error('Something bad happened while geting sha for ' + filePath);
+        logger.debug(err);
+    }
+    return pathStatObject;
+}
+
+/**
+ * Gets sha256 and Size for all the elements of
+ * given filePath Synchronusly.
+ *
+ * @param {String} filePath
+ */
+function getSHA256AndSizeForPathSync (filePath, shaMap, skipRegex) {
+    const pathStatObject = {
+        shaList: [],
+        sizeList: []
+    };
+    if (skipRegex && filePath && filePath.match(skipRegex)) {
+        return pathStatObject;
+    }
+    try {
+        const stats = getStatsSync(filePath);
+        if (stats.isDirectory()) {
+            const fileList = getSortedDirContentSync(filePath);
+            if (fileList) {
+                for (const file of fileList) {
+                    const calledStateObject = getSHA256AndSizeForPathSync(file, shaMap, skipRegex);
+                    pathStatObject.shaList = pathStatObject.shaList.concat(calledStateObject.shaList);
+                    pathStatObject.sizeList = pathStatObject.sizeList.concat(calledStateObject.sizeList);
+                }
+            }
+        } else if (filePath.match(INCLUDED_FILE_EXT_REGEX)) {
+            const sha = getSHA256ForFileSync(filePath);
+            const fileSizeInBytes = stats.size;
+            if (sha && sha !== null) {
+                pathStatObject.shaList.push(sha);
+                if (fileSizeInBytes) {
+                    pathStatObject.sizeList.push(fileSizeInBytes);
+                }
+            }
+        }
+    } catch (err) {
+        logger.error('Something bad happened while geting sha for ' + filePath);
+        logger.debug(err);
+    }
+    return pathStatObject;
+}
+
+/**
+ * Gets all the source and prop files
+ * in the passed directory.
+ * @param {String} dirPath
+ */
+async function getSortedDirContent (dirPath) {
+    return new CurrentPromise(async function (resolve, reject) {
+        try {
+            const stats = await getStats(dirPath);
+            if (stats.isDirectory()) {
+                fs.readdir(dirPath, function (err, files) {
+                    if (err) {
+                        logger.error('Unable to get directory content: ', dirPath);
+                        reject(err);
+                    }
+
+                    // resolve file paths
+                    for (let counter = 0; counter < files.length; counter++) {
+                        files[counter] = path.resolve(dirPath, files[counter]);
+                    }
+
+                    // sort
+                    files = files.sort();
+
+                    resolve(files);
+                });
+            } else {
+                const err = new Error('Not a directory: ' + dirPath);
+                logger.error(err);
+                reject(err);
+            }
+        } catch (err) {
+            logger.error('Unable to get directory content: ', dirPath);
+            reject(err);
+        }
+    });
+}
+
+/**
+ * Gets all the source and prop files
+ * in the passed directory Sync.
+ * @param {String} dirPath
+ */
+function getSortedDirContentSync (dirPath) {
+    try {
+        const stats = getStatsSync(dirPath);
+        if (stats.isDirectory()) {
+            try {
+                let files = fs.readdirSync(dirPath);
+
+                // resolve file paths
+                for (let counter = 0; counter < files.length; counter++) {
+                    files[counter] = path.resolve(dirPath, files[counter]);
+                }
+
+                // sort
+                files = files.sort();
+
+                return files;
+            } catch (err) {
+                logger.error('Unable to get directory content: ', dirPath);
+                throw err;
+            }
+        } else {
+            const err = new Error('Not a directory: ' + dirPath);
+            logger.error(err);
+            throw err;
+        }
+    } catch (err) {
+        logger.error('Unable to get directory content: ', dirPath);
+        throw err;
+    }
+}
+
+/**
+ * Calculates SHA256 for a file.
+ * @param {String} filePath
+ */
+async function getSHA256ForFile (filePath) {
+    if (CurrentPromise) {
+        return new CurrentPromise((resolve, reject) => {
+            if (filePath) {
+            } else {
+                const err = new Error('Empty FilePath!');
+                reject(err);
+            }
+        });
+    } else {
+        logger.debug('Promise haven\'t been set!');
+        return {};
+    }
+}
+
+/**
+ * Calculates SHA256 for a file synchronously.
+ * @param {String} filePath
+ */
+function getSHA256ForFileSync (filePath) {
+    if (!filePath) {
+        throw new Error('Empty FilePath!');
+    }
+    try {
+        const fd = fs.openSync(filePath);
+        const content = fs.readFileSync(fd, { encoding: 'UTF-8' });
+        fs.closeSync(fd);
+        return getSHA256ForData(content);
+    } catch (err) {
+        logger.error('Unable to calculate SHA256 for file: ' + filePath);
+        throw err;
+    }
+}
+
+/**
+ * Generates SHA256 for passed data
+ * @param {String} data
+ */
+function getSHA256ForData (data) {
+    try {
+        if (!process.traceMap) {
+            return hash.sha256().update(data).digest(HEX_DIGEST); ;
+        }
+        const cachedSha = process.traceMap.get(data);
+
+        if (cachedSha) {
+            return cachedSha;
+        } else {
+            const calSha = hash.sha256().update(data).digest(HEX_DIGEST);
+            if (process.traceMap.size < 2000 && (httpreq && httpreq.data)) {
+                process.traceMap.set(data, calSha);
+            }
+            return calSha;
+        }
+    } catch (err) {
+        logger.error('Unable to calculate SHA256 for data.');
+        logger.debug(err);
+        return null;
+    }
+}
+
+/**
+ * returns HumanReadable form of passed Bytes
+ * @param {Number} bytes
+ */
+function getHumanReadableSize (bytes) {
+    if (Math.abs(bytes) < thresh) {
+        return bytes + ' B';
+    }
+    let u = -1;
+    do {
+        bytes /= thresh;
+        ++u;
+    } while (Math.abs(bytes) >= thresh && u < units.length - 1);
+    return bytes.toFixed(1) + ' ' + units[u];
+}
+
+/**
+ * Sets logger for this module.
+ */
+function setLogger (logr) {
+    logger = logr;
+}
+
+/**
+ * Sets promise for this module.
+ */
+function setPromise (promise) {
+    CurrentPromise = promise;
+}
+
+/**
+ * Checks if the given path represents a directory
+ */
+async function getStats (path) {
+    return new CurrentPromise((resolve, reject) => {
+        fs.lstat(path, function (err, stat) {
+            if (err) {
+                logger.error('Unable to get stats for: ', path);
+                reject(err);
+            }
+            resolve(stat);
+        });
+    });
+}
+
+/**
+ * Checks if the given path represents a directory
+ */
+function getStatsSync (path) {
+    return fs.lstatSync(path);
+}

package/lib/nr-security-agent/lib/core/sha_worker.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const { workerData, parentPort } = require('worker_threads');
+const shaSizeUtil = require('./sha-size-util');
+const logs = require('./logging');
+const logger = logs.getLogger(workerData.applicationUUID);
+shaSizeUtil.setLogger(logger);
+const MESSAGE = 'message';
+
+async function computeSHA (path) {
+    logger.info('Started computing SHA and size in worker thread');
+    const data = await shaSizeUtil.getApplicationSHAAndSize(path, global.Promise);
+    parentPort.postMessage(data);
+    parentPort.unref();
+    logger.debug('Terminating SHA worker');
+    process.exit(0);
+}
+
+parentPort.on(MESSAGE, (param) => {
+    computeSHA(param);
+});