@newrelic/security-agent 1.1.1 → 1.3.0

package/lib/instrumentation-security/hooks/fs/nr-fs.js

@@ -138,9 +138,9 @@ function openHook(shim, mod, moduleName) {
         if (!trimedURL.includes(path.basename(parameters[0])) || decodedURL.includes(DOTDOTSLASH) || dynamicScanningFlag) {
           try {
             if (parameters[0].startsWith(DOTDOTSLASH)) {
-              parameters[0] = agentModule.applicationInfo.serverInfo.deployedApplications[0].deployedPath + SLASH + parameters[0];
+              parameters[0] = API.getSecAgent().applicationInfo.serverInfo.deployedApplications[0].deployedPath + SLASH + parameters[0];
             } else if (parameters[0].startsWith(SLASHDOTDOT)) {
-              parameters[0] = agentModule.applicationInfo.serverInfo.deployedApplications[0].deployedPath + parameters[0];
+              parameters[0] = API.getSecAgent().applicationInfo.serverInfo.deployedApplications[0].deployedPath + parameters[0];
             } else {
               parameters[0] = path.resolve(parameters[0]);
             }
@@ -347,7 +347,7 @@ function getCaseType(flag, filePath) {
       case fsConsts.O_APPEND | fsConsts.O_CREAT | fsConsts.O_RDWR | fsConsts.O_EXCL:
       case fsConsts.O_APPEND | fsConsts.O_CREAT | fsConsts.O_RDWR | fsConsts.O_SYNC:
         filePath = path.resolve(filePath);
-        const appPath = agentModule.applicationInfo.serverInfo.deployedApplications[0].deployedPath;
+        const appPath = API.getSecAgent().applicationInfo.serverInfo.deployedApplications[0].deployedPath;
         const isInPath = isPathInside(filePath, appPath);
         if (typeof filePath === STRING && isInPath) {
           return EVENT_TYPE.FILE_INTEGRITY;
@@ -364,7 +364,7 @@ function getCaseType(flag, filePath) {
  */
 function getCase(filePath) {
   filePath = path.resolve(filePath);
-  const appPath = agentModule.applicationInfo.serverInfo.deployedApplications[0].deployedPath;
+  const appPath = API.getSecAgent().applicationInfo.serverInfo.deployedApplications[0].deployedPath;
   const isInPath = isPathInside(filePath, appPath);
   if (typeof filePath === STRING && isInPath) {
     return EVENT_TYPE.FILE_INTEGRITY;

package/lib/instrumentation-security/hooks/grpc-js/nr-grpc.js

@@ -0,0 +1,301 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: New Relic Pre-Release
+ */
+
+
+const requestManager = require("../../core/request-manager");
+const secUtils = require("../../core/sec-utils");
+const API = require("../../../nr-security-api");
+const securityMetaData = require('../../core/security-metadata');
+const { EVENT_TYPE, EVENT_CATEGORY } = require('../../core/event-constants');
+const { NR_CSEC_FUZZ_REQUEST_ID } = require('../../core/constants');
+const logger = API.getLogger();
+const semver = require('semver');
+const grpcutils = require('../../core/grpc-utils');
+let serverAddress;
+
+module.exports.initialize = function initialize(shim, grpc, moduleName) {
+  logger.info('Instrumenting grpc', moduleName);
+  const grpcVersion = shim.require('./package.json').version;
+  logger.debug("grpc version:", grpcVersion);
+
+  if (semver.lt(grpcVersion, '1.4.0')) {
+    logger.warn('gRPC server-side instrumentation only supported on grpc-js >=1.4.0')
+    return
+  }
+
+  if (semver.gte(grpcVersion, '1.8.0')) {
+    const resolvingCall = shim.require('./build/src/resolving-call')
+    shim.wrap(resolvingCall.ResolvingCall.prototype, 'start', wrapStart)
+  } else {
+    const callStream = shim.require('./build/src/call-stream')
+    shim.wrap(callStream.Http2CallStream.prototype, 'start', wrapStart)
+  }
+
+  const server = shim.require('./build/src/server')
+  shim.wrap(server.Server.prototype, 'bindAsync', bindAsyncWrapper)
+  shim.wrap(server.Server.prototype, 'register', wrapRegister)
+
+  //get all service
+  shim.wrap(server.Server.prototype, 'addService', wrapAddService);
+
+  //load package definition
+  const makeClient = shim.require('./build/src/make-client');
+  shim.wrap(makeClient, 'loadPackageDefinition', wrapLoadPackageDefinition);
+
+}
+
+module.exports.wrapStartResolve = function wrappedStartResolve(shim, resolvingCall) {
+  shim.wrap(resolvingCall.ResolvingCall.prototype, 'start', wrapStart)
+}
+
+module.exports.wrapStartCall = function wrappedClient(shim, callStream) {
+  shim.wrap(callStream.Http2CallStream.prototype, 'start', wrapStart)
+}
+
+module.exports.wrapServer = function wrappedServer(shim, server) {
+  const grpcVersion = shim.require('./package.json').version
+  logger.info("Instrumenting @grpc/grpc-js", grpcVersion)
+  if (semver.lt(grpcVersion, '1.4.0')) {
+    logger.warn('gRPC server-side instrumentation only supported on grpc-js >=1.4.0')
+    return
+  }
+
+  shim.wrap(server.Server.prototype, 'register', wrapRegister)
+  shim.wrap(server.Server.prototype, 'bindAsync', bindAsyncWrapper)
+  //get all service
+  shim.wrap(server.Server.prototype, 'addService', wrapAddService);
+}
+
+module.exports.wrapMakeClient = function wrapMakeClient(shim, makeClient) {
+  shim.wrap(makeClient, 'loadPackageDefinition', wrapLoadPackageDefinition);
+}
+
+
+/**
+ * Instruments grpc-js client by intercepting the function that
+ * initiates client requests. This handles all four types of client
+ * invocations: unary, client-streaming, server-streaming, and
+ * bidirectional streaming.
+ *
+ * @param {object} shim the generic shim to instrument with
+ * @param {Function} original the original function
+ * @returns {Function} the instrumented function
+ */
+function wrapStart(shim, original) {
+  if (!shim.isFunction(original)) {
+    return original
+  }
+  return function wrappedStart() {
+    const channel = this.channel;
+    const authorityName = (channel.target && channel.target.path) || channel.getDefaultAuthority;
+    // in 1.8.0 this changed from methodName to method
+    const method = this.methodName || this.method;
+    const protocol = 'grpc:';
+    const url = `${protocol}//${authorityName}${method}`;
+    logger.debug("grpc url is:", url)
+    const request = requestManager.getRequest(shim);
+    let urlObj = {
+      "headers":
+      {
+        "host": authorityName
+      },
+      "method": method,
+      "path": method,
+      "protocol": protocol,
+    }
+    if (request) {
+      const traceObject = secUtils.getTraceObject(shim);
+      const secMetadata = securityMetaData.getSecurityMetaData(request, urlObj, traceObject, secUtils.getExecutionId(), EVENT_TYPE.HTTP_REQUEST, EVENT_CATEGORY.HTTP)
+      const secEvent = API.generateSecEvent(secMetadata);
+      API.sendEvent(secEvent);
+    }
+
+    const res = original.apply(this, arguments);
+    return res;
+  }
+}
+
+
+
+function wrapAddService(shim, original) {
+  if (!shim.isFunction(original)) {
+    return original
+  }
+  return function wrappedbindAsync() {
+    const result = original.apply(this, arguments);
+    return result;
+  }
+}
+
+function wrapLoadPackageDefinition(shim, original) {
+  if (!shim.isFunction(original)) {
+    return original
+  }
+  return function wrappedbindAsync() {
+    let serviceObject = arguments[0];
+    const result = original.apply(this, arguments);
+    iterateNestedObjectForServiceLookup(result, serviceObject);
+    return result;
+  }
+}
+
+
+
+
+function bindAsyncWrapper(shim, original) {
+  if (!shim.isFunction(original)) {
+    return original
+  }
+  return function wrappedbindAsync() {
+    serverAddress = arguments[0];
+    shim.grpcServerAddress = serverAddress;
+    try {
+      const splittedData = serverAddress.split(":");
+      serverPort = splittedData[1];
+      shim.serverPort = parseInt(serverPort);
+    } catch (error) {
+
+    }
+    const result = original.apply(this, arguments);
+    return result;
+  }
+}
+
+
+
+/**
+ * Instruments the grpc-js server by intercepting the moment when
+ * server methods are registered from the method implementations
+ * provided to grpc-js. This handles all four types of server
+ * invocations: unary, client-streaming, server-streaming, and
+ * bidirectional streaming.
+ *
+ * @param {object} shim the web shim to instrument with
+ * @param {Function} original the original function
+ * @returns {Function} the instrumented function
+ */
+function wrapRegister(shim, original) {
+  if (!shim.isFunction(original)) {
+    return original
+  }
+  return function wrappedRegister() {
+    wrapHandler(shim, arguments, '1');
+    const result = original.apply(this, arguments);
+    return result;
+  }
+}
+
+
+/**
+ * Wrapper to hook handler function
+ * @param {*} shim 
+ * @param {*} mod 
+ * @param {*} method 
+ */
+function wrapHandler(shim, mod, method) {
+  shim.wrap(mod, method, function wrapHandler(shim, fn) {
+    if (!shim.isFunction(fn)) {
+      return fn
+    }
+    return function wrappedHandler() {
+      const type = this.type;
+      const path = this.path;
+      wrapCallback(shim, arguments, '1');
+      addRequestData(shim, type, path, arguments[0]);
+      const result = fn.apply(this, arguments);
+      return result;
+
+    }
+  })
+}
+
+/**
+ * Wrapper to hook callback response
+ * @param {*} shim 
+ * @param {*} mod 
+ * @param {*} method 
+ */
+function wrapCallback(shim, mod, method) {
+  shim.wrap(mod, method, function wrapCallback(shim, fn) {
+    if (!shim.isFunction(fn)) {
+      return fn
+    }
+    return function wrappedCallback() {
+      const response = arguments[1];
+      const result = fn.apply(this, arguments);
+      return result;
+
+    }
+  })
+}
+
+/**
+ * Utility function to add grpc request data in request map
+ * @param {*} shim 
+ * @param {*} type 
+ * @param {*} path 
+ * @param {*} args 
+ */
+function addRequestData(shim, type, path, args) {
+  const data = Object.assign({});
+  try {
+    const segment = shim.getActiveSegment();
+    if (segment && segment.transaction) {
+      data.method = path;
+      data.url = path;
+      data.uri = path;
+      data.headers = args.metadata.getMap();
+      if (data.headers && data.headers[NR_CSEC_FUZZ_REQUEST_ID]) {
+        let bufferObj = Buffer.from(data.headers[NR_CSEC_FUZZ_REQUEST_ID], "base64");
+        let decodedString = bufferObj.toString("utf8");
+        data.headers[NR_CSEC_FUZZ_REQUEST_ID] = decodedString;
+      }
+      data.type = type;
+      data.protocol = 'grpc';
+      data.isGRPC = true;
+      data.body = JSON.stringify(args.request);
+      data.serverPort = shim.serverPort;
+      const transactionId = segment.transaction.id;
+      requestManager.setRequest(transactionId, data);
+    }
+  } catch (error) {
+    logger.error("Error occured while extracting grpc request", error);
+  }
+}
+
+/**
+ * Utilty to set grpc util Maps
+ * @param {*} serviceObject 
+ */
+function serviceUtil(serviceObject) {
+  let serviceValues = Object.values(serviceObject)[0];
+  for (const [key, value] of Object.entries(serviceValues)) {
+    let servObj = {
+      'serviceName': serviceObject.serviceName,
+      'originalName': value.originalName,
+    }
+    grpcutils.setMethod(value.path, servObj);
+  }
+}
+
+function iterateNestedObjectForServiceLookup(result, serviceObject) {
+  try {
+    for (const key in result) {
+      if (typeof result[key] === 'object' && result[key] !== 'null') {
+        iterateNestedObjectForServiceLookup(result[key], serviceObject); // Recurse into nested object
+      } else {
+        let value = result[key];
+        if (value && value.serviceName) {
+          if (!value.type && value.serviceName) {
+            grpcutils.setService(value.serviceName, serviceObject);
+            serviceUtil(value);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    logger.error("Error while getting service definition", error);
+  }
+}

package/lib/instrumentation-security/hooks/http/nr-http.js

@@ -5,7 +5,7 @@
 
 module.exports = initialize
 const requestManager = require('../../core/request-manager');
-const { NR_CSEC_FUZZ_REQUEST_ID, QUESTION_MARK, EMPTY_STRING, UTF8, CONTENT_TYPE, TEXT_HTML, APPLICATION_JSON, APPLICATION_XML, APPLICATION_XHTML, TEXT_PLAIN, APPLICATION_X_FORM_URLENCODED, MULTIPART_FORM_DATA } = require('../../core/constants');
+const { NR_CSEC_FUZZ_REQUEST_ID, QUESTION_MARK, EMPTY_STRING, UTF8, CONTENT_TYPE, TEXT_HTML, APPLICATION_JSON, APPLICATION_XML, APPLICATION_XHTML, TEXT_PLAIN, APPLICATION_X_FORM_URLENCODED, MULTIPART_FORM_DATA, COMMA } = require('../../core/constants');
 const ARRAY_TYPE = 'Array';
 const STRING_TYPE = 'string';
 const BUFFER_TYPE = 'Buffer';
@@ -168,27 +168,38 @@ function parseFuzzheaders(requestData, transactionId) {
     try {
       const additionalData = fuzzheaders[NR_CSEC_FUZZ_REQUEST_ID].split(CSEC_SEP);
       logger.debug('AdditionalData:', additionalData);
-      if (additionalData.length >= 7) {
-        for (let i = 6; i < additionalData.length; i++) {
-          let file = additionalData[i].trim();
-          file = file.replace(CSEC_HOME_TMP_CONST, CSEC_HOME_TMP);
-          file = path.resolve(file);
-          const parentDir = path.dirname(file);
-          if (!isInvalid(parentDir) && isPathInside(parentDir, CSEC_HOME_TMP)) {
-            try {
-              if (!fs.existsSync(parentDir)) {
-                secUtils.createPathIfNotExist(parentDir);
-              } else {
-                logger.debug(parentDir + ' Already Exists');
+      if (additionalData.length >= 8) {
+        let encryptedData = additionalData[6];
+        let hashVerifier = additionalData[7];
+        let decryptedData = secUtils.decryptData(encryptedData);
+        let verifiedHash = secUtils.hashVerifier(decryptedData, hashVerifier);
+        logger.debug("verifiedHash:", verifiedHash);
+        let filesToCreate = decryptedData.split(COMMA);
+        if (verifiedHash) {
+          logger.debug("Encrypted Data:", encryptedData);
+          logger.debug("Decrypted Data:", decryptedData)
+          logger.debug("fliesTocreate:",filesToCreate);
+          for (let i = 0; i < filesToCreate.length; i++) {
+            let file = filesToCreate[i].trim();
+            file = file.replace(CSEC_HOME_TMP_CONST, CSEC_HOME_TMP);
+            file = path.resolve(file);
+            const parentDir = path.dirname(file);
+            if (!isInvalid(parentDir) && isPathInside(parentDir, CSEC_HOME_TMP)) {
+              try {
+                if (!fs.existsSync(parentDir)) {
+                  secUtils.createPathIfNotExist(parentDir);
+                } else {
+                  logger.debug(parentDir + ' Already Exists');
+                }
+                fs.closeSync(fs.openSync(file, 'w'));
+  
+                requestData.tempFiles = [];
+                requestData.tempFiles.push(file);
+                requestManager.setRequest(transactionId, requestData);
+  
+              } catch (error) {
+                logger.debug(error);
               }
-              fs.closeSync(fs.openSync(file, 'w'));
-
-              requestData.tempFiles = [];
-              requestData.tempFiles.push(file);
-              requestManager.setRequest(transactionId, requestData);
-
-            } catch (error) {
-              logger.debug(error);
             }
           }
         }
@@ -392,7 +403,7 @@ function responseHook(resp, req, shim) {
       const dynamicScanningFlag = policy.data ? (policy.data.vulnerabilityScan?.enabled && policy.data.vulnerabilityScan.iastScan.enabled) : false;
       const type = response.getHeader(CONTENT_TYPE);
       let isUnsupportedType = isUnsupportedContentType(type);
-      
+
       if (request && (construct || dynamicScanningFlag) && !isUnsupportedType) {
         const args = [];
         args.push(construct);
@@ -400,7 +411,7 @@ function responseHook(resp, req, shim) {
         const traceObject = secUtils.getTraceObject(shim);
         const secMetadata = securityMetaData.getSecurityMetaData(request, args, traceObject, secUtils.getExecutionId(), EVENT_TYPE.REFLECTED_XSS, EVENT_CATEGORY.REFLECTED_XSS)
         const secEvent = API.generateSecEvent(secMetadata);
-        secEvent.httpResponse  = {};
+        secEvent.httpResponse = {};
         secEvent.httpResponse.contentType = response.getHeader(CONTENT_TYPE);
         API.sendEvent(secEvent);
       }

package/lib/instrumentation-security/index.js

@@ -199,10 +199,39 @@ newrelic.instrumentWebframework({
   }
 })
 
+newrelic.instrument({
+  moduleName: '@grpc/grpc-js/build/src/server',
+  isEsm: true,
+  onRequire: require('./hooks/grpc-js/nr-grpc').wrapServer,
+  onError: function intrumentErrorHandler(err) {
+    logger.error(err.message, err.stack)
+  }
+})
 
+newrelic.instrument({
+  moduleName: '@grpc/grpc-js/build/src/make-client',
+  isEsm: true,
+  onRequire: require('./hooks/grpc-js/nr-grpc').wrapMakeClient,
+  onError: function intrumentErrorHandler(err) {
+    logger.error(err.message, err.stack)
+  }
+})
 
+newrelic.instrument({
+  moduleName: '@grpc/grpc-js/build/src/resolving-call',
+  isEsm: true,
+  onRequire: require('./hooks/grpc-js/nr-grpc').wrapStartResolve,
+  onError: function intrumentErrorHandler(err) {
+    logger.error(err.message, err.stack)
+  }
+})
 
-
-
-
+newrelic.instrument({
+  moduleName: '@grpc/grpc-js/build/src/call-stream',
+  isEsm: true,
+  onRequire: require('./hooks/grpc-js/nr-grpc').wrapStartCall,
+  onError: function intrumentErrorHandler(err) {
+    logger.error(err.message, err.stack)
+  }
+})
 

package/lib/nr-security-agent/index.js

@@ -16,6 +16,13 @@ const njsAgentConstants = require('./lib/core/sec-agent-constants');
 
 const NRLogger = API.newrelic.shim.logger.child({ component: 'security-agent' });
 NRLogger.info("Starting New Relic Node.js Security Agent ");
+try {
+    if (NRAgent.config.security.enabled){
+        require('../instrumentation-security');
+    }
+} catch (error) {
+    logger.error("Error while applying security instrumentation")
+}
 
 const {
     IS_LAMBDA_ENV,
@@ -169,7 +176,6 @@ function getProcCMDLineSanitized(applicationInfoModule) {
         return;
     }
     if (initialize()) {
-        require('../instrumentation-security');
         initLogger.info("[STEP-6] => Application instrumentation applied successfully");
     }
 })();

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

@@ -51,7 +51,6 @@ function setPolicyData(data) {
         policy.data = data;
         appInfoVersionUpdate(policy, data);
         initLogger.info("[STEP-7] => Received and applied policy/configuration", JSON.stringify(policy.data));
-        logger.info('Applied policy is:', JSON.stringify(policy.data));
         if (NRAgent && NRAgent.config.security.detection) {
             logger.info('Security detection flags:', JSON.stringify(NRAgent.config.security.detection));
         }

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

@@ -12,7 +12,7 @@ const OS = require('os');
 const path = require('path');
 const checkDiskSpace = require('check-disk-space').default;
 const AgentStatus = require('../core/agent-status');
-const { CSEC_HOME, SLASH } = require('./sec-agent-constants');
+const { CSEC_HOME, SLASH, EMPTY_STR } = require('./sec-agent-constants');
 
 const njsAgentConstants = require('./sec-agent-constants');
 const API = require('../../../nr-security-api');
@@ -107,7 +107,7 @@ function createPathIfNotExist(dir) {
     } catch (error) {
         logger.debug(dir + ' Not Created', error);
         const LogMessage = require('./LogMessage');
-        const logMessage = new LogMessage.logMessage("SEVERE", 'Error in creating directory', __filename, error);
+        const logMessage = new LogMessage.logMessage("DEBUG", 'Error in creating directory', __filename, error);
         addLogEventtoBuffer(logMessage);
     }
 }
@@ -288,7 +288,7 @@ function removeOlderSnapshots() {
     } catch (error) {
         logger.debug(error);
         const LogMessage = require('./LogMessage');
-        const logMessage = new LogMessage.logMessage("SEVERE", 'Error in processing snapshot files', __filename, error);
+        const logMessage = new LogMessage.logMessage("DEBUG", 'Error in processing snapshot files', __filename, error);
         addLogEventtoBuffer(logMessage);
     }
 }
@@ -445,6 +445,20 @@ function addLogEventtoBuffer(logMessage) {
         logger.debug(error);
     }
 }
+/**
+ * Utility to get framework from APM
+ * @returns 
+ */
+function getFramework(){
+    let framework = EMPTY_STR;
+    try {
+        framework = NRAgent.environment.get('Framework')[0];
+    } catch (error) {
+        logger.debug("Unable to get framework");
+    }
+    return framework;
+}
+
 
 module.exports = {
     getUUID,
@@ -469,5 +483,6 @@ module.exports = {
     getWSHealthStatus,
     setWSHealthStatus,
     addLogEventtoBuffer,
-    getLogEvents
+    getLogEvents,
+    getFramework
 };

package/lib/nr-security-agent/lib/core/connections/grpcClient.js

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: New Relic Pre-Release
+ */
+const logger = require('../logging').getLogger();
+const grpcutils = require('../../../../instrumentation-security/core/grpc-utils');
+const clientMap = new Map();
+let grpc;
+const { NR_CSEC_FUZZ_REQUEST_ID } = require('../../core/sec-agent-constants');
+
+/**
+ * Utility to get client object
+ * @param {*} config 
+ * @returns 
+ */
+function getGPRCClient(config) {
+    let grpc = require("@grpc/grpc-js");
+    try {
+        const serviceName = grpcutils.getMethod(config.method).serviceName;
+
+        if (clientMap.has(serviceName)) {
+            return clientMap.get(serviceName);
+        }
+        const serviceObject = grpcutils.getService(serviceName);
+        const definition = grpc.loadPackageDefinition(serviceObject);
+        let service = getNestedValue(definition, serviceName)
+        if (service) {
+            logger.info("GRPC client service extracted successfully");
+        }
+        const client = new service(
+            "localhost:" + config.serverPort,
+            grpc.credentials.createInsecure()
+        );
+        if (!clientMap.has(serviceName)) {
+            clientMap.set(serviceName, client);
+        }
+        if(client){
+            logger.info("GRPC IAST client created successfully");
+        }
+        return client;
+    } catch (error) {
+        logger.error("error while creating client:", error);
+    }
+
+}
+
+/**
+ * Utility to fire unary requests
+ * @param {*} client 
+ * @param {*} config 
+ */
+function fireUnaryRequest(client, config) {
+    try {
+        const methodObj = grpcutils.getMethod(config.requestURI);
+        if (methodObj && methodObj.originalName) {
+            let method = methodObj.originalName;
+            let metadata = new grpc.Metadata();
+            let bufferObj = Buffer.from(config.headers[NR_CSEC_FUZZ_REQUEST_ID], "utf8");
+            let base64String = bufferObj.toString("base64");
+            metadata.add(NR_CSEC_FUZZ_REQUEST_ID, base64String);
+            client[method](JSON.parse(config.data), metadata, (err, res) => {
+                if (err) {
+                    logger.debug("Error occured:", err);
+                    return
+                }
+
+                logger.info("Fuzz success: ", JSON.stringify(config));
+                return res;
+            })
+        }
+        else {
+            logger.debug("Not Found:", config.url);
+        }
+    } catch (error) {
+        logger.debug("Error while firing Unary request:", error);
+    }
+}
+
+/**
+ * fire gRPC request based on provided config 
+ * @param {*} config 
+ * @returns 
+ */
+function fireRequest(config) {
+    try {
+        grpc = require("@grpc/grpc-js");
+    } catch (error) {
+        logger.debug("Unable to import grpc module", error);
+    }
+    let client = getGPRCClient(config);
+    fireUnaryRequest(client, config)
+}
+
+
+  function getNestedValue(obj, targetKey) {
+    for (const key in obj) {
+      if (key === targetKey) {
+        return obj[key];
+      } else if (typeof obj[key] === 'object' && obj[key] !== null) {
+        const result = getNestedValue(obj[key], targetKey);
+        if (result !== undefined) {
+          return result;
+        }
+      }
+    }
+    return undefined; // Key not found
+  }
+
+
+module.exports = {
+    fireRequest
+};

package/lib/nr-security-agent/lib/core/connections/websocket/response/IASTUtils.js

@@ -31,6 +31,9 @@ function completedRequestsMapInit(id) {
 
 function addCompletedRequests(id, eventId) {
     let data = completedRequestsMap.get(id);
+    if(!data){
+        return;
+    }
     data.push(eventId);
     completedRequestsMap.set(id, data);
 }