@newrelic/security-agent 0.0.1

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+let podProperties;
+function PodProperties () {
+
+}
+PodProperties.prototype.constructor = PodProperties;
+
+/**
+ * Returns the current instanceof PodProperties,
+ * creates one if not already created.
+ *
+ * @returns {PodProperties} instance
+ */
+function getInstance () {
+    if (!podProperties) {
+        podProperties = new PodProperties();
+        podProperties.name = '';
+        podProperties.namespace = '';
+        podProperties.clusterName = '';
+        podProperties.clusterId = '';
+        podProperties.entrypoint = '';
+        podProperties.ipAddress = '';
+        podProperties.hostIpAddress = '';
+        podProperties.creationTimestamp = '';
+        podProperties.containerProperties = [];
+    }
+    return podProperties;
+}
+
+module.exports = {
+    getInstance
+};

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

@@ -0,0 +1,105 @@
+
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const API = require('../../../nr-security-api');
+const NRAgent = API.getNRAgent();
+const { Agent } = require('./agent');
+
+let policy;
+const path = require('path');
+const fs = require('fs');
+const yaml = require('js-yaml');
+const logs = require('./logging');
+const logger = logs.getLogger();
+const initLogger = logs.getInitLogger();
+const jsonValidator = require('./jsonValidator');
+const LOG_MESSAGES = require('./sec-agent-constants').LOG_MESSAGES;
+const statusUtils = require('./statusUtils');
+
+function Policy() {
+    this.data = {};
+}
+Policy.prototype.constructor = Policy;
+
+/**
+ * Returns the current instanceof Policy,
+ * creates one if not already created.
+ *
+ * @returns {Policy} instance
+ */
+function getInstance() {
+    if (!policy) {
+        policy = new Policy();
+    }
+    return policy;
+}
+
+
+// sets up policy data to use globally.
+function setPolicyData(data) {
+    policy = getInstance();
+    const jsonValidationResult = jsonValidator.validate(data);
+    if (jsonValidationResult && jsonValidationResult.errors && jsonValidationResult.errors.length > 0) {
+        logger.error(LOG_MESSAGES.EXP_RAISE_POL, JSON.stringify(jsonValidationResult.errors));
+        logger.info(LOG_MESSAGES.FALLBACK_TO_CURR_POLICY, JSON.stringify(policy.data));
+        return false;
+    }
+    if (policy.data.version !== data.version) {
+        policy.data = data;
+        appInfoVersionUpdate(policy, data);
+        initLogger.info(LOG_MESSAGES.POLICY_APPLIED, 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));
+        }
+        return true;
+    }
+}
+
+// function to setup default policy provided in resources directory
+function setDefaultPolicy() {
+    const default_policy_file = path.resolve(__dirname, '../../resources/default-policy.yaml');
+    // Get document, or throw exception on error
+    try {
+        const default_policy = yaml.load(fs.readFileSync(default_policy_file, 'utf8'));
+        policy = getInstance();
+        policy.data = default_policy;
+        logger.info(LOG_MESSAGES.DEFAULT_POL_SET, JSON.stringify(policy.data));
+    } catch (e) {
+        logger.error(LOG_MESSAGES.UNABLE_SET_DEFAULT_POL, e);
+        statusUtils.addErrortoBuffer(e);
+    };
+}
+
+/**
+ * Function to set applicationInfo with updated policy version
+ * @param {*} policy 
+ * @param {*} data 
+ */
+function appInfoVersionUpdate(policy, data) {
+    const appInfo = require('./applicationinfo').getInstance();
+    const { Agent } = require('./agent');
+    appInfo.policyVersion = data.version || policy.data.version;
+    if (NRAgent && appInfo.entityGuid) {
+        Agent.getAgent().setApplicationInfo(appInfo);
+    }
+}
+
+/**
+ * Function to send updated policy to validator
+ * @param {*} data 
+ */
+function sendUpdatedPolicy(data) {
+    const wsClient = Agent.getAgent().client;
+    let updatedPolicy = Object.assign({}, data);
+    updatedPolicy.jsonName = 'lc-policy';
+    wsClient.dispatcher(updatedPolicy);
+}
+module.exports = {
+    getInstance,
+    setPolicyData,
+    setDefaultPolicy
+};

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const SecAgentStatus = function () {
+    if (Object.getPrototypeOf(this).constructor !== SecAgentStatus) {
+        return new SecAgentStatus();
+    }
+    if (!SecAgentStatus.instance) {
+        SecAgentStatus.instance = this;
+        let status = SecAgentStatus.codes.CONNECTING;
+        const codeList = [];
+        for (let code in SecAgentStatus.codes) {
+            codeList.push(SecAgentStatus.codes[code])
+        }
+        this.getStatus = function () {
+            return status;
+        }
+        this.setStatus = function (STATUS) {
+            if (STATUS && codeList.includes(STATUS)) {
+                status = STATUS;
+            } else {
+                throw new Error("Unknown Status");
+            }
+        }
+    } else {
+        return SecAgentStatus.instance;
+    }
+}
+SecAgentStatus.prototype.constructor = SecAgentStatus;
+
+/**
+ * Valid values to set agent status.
+ */
+SecAgentStatus.codes = {
+    CONNECTING: 'connecting',
+    ACTIVE: "active",
+    DISABLED: "disabled",
+    DETACHED: "detached"
+}
+
+/**
+ * Get instance of CSECAgentStatus.
+ */
+const getInstance = function () {
+    if (!SecAgentStatus.instance) {
+        return new SecAgentStatus();
+    } else {
+        return SecAgentStatus.instance;
+    }
+}
+
+module.exports = {
+    CSECAgentStatus: SecAgentStatus,
+    getInstance
+};

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

@@ -0,0 +1,146 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const { EventEmitter } = require('events');
+
+const APPLICATION_INFO_UPDATE_EVENT = 'application-info-updated';
+const WS_CONNECTION_STATUS_UPDATE_EVENT = 'ws-connection-updated';
+const AGENT_STATUS_UPDATED_EVENT = 'agent-status-updated';
+const WS_UPDATE_EVENT = 'websocket-updated';
+const RECONNECT_WS_EVENT = 'reconnect-websocket';
+const LOG_MESSAGES = require('./sec-agent-constants').LOG_MESSAGES;
+const LinkingMetaData = require('./LinkingMetadata');
+const API = require('../../../nr-security-api');
+let NRAgent = API.getNRAgent();
+const agentConfig = require('../../resources/config')
+
+const EVENTS = {
+    APPLICATION_INFO_UPDATE_EVENT,
+    WS_CONNECTION_STATUS_UPDATE_EVENT,
+    AGENT_STATUS_UPDATED_EVENT,
+    WS_UPDATE_EVENT,
+    RECONNECT_WS_EVENT
+};
+
+let instance = null;
+/**
+ * This defines the CSEC agent instance which would hold
+ * necessary info for agent.
+ *
+ * @param {ApplicationInfo} applicationInfo
+ * @param {Logger} logger
+ * @param {WebSocket} client
+ * @param {AgentStatus} status
+ */
+function Agent(applicationInfo, logger, client, status) {
+    const version = require(agentConfig.AGENT_DIR + '/package.json').version;
+    this.applicationInfo = applicationInfo;
+    this.client = client;
+    this.version = version;
+    this.logger = logger;
+    this.status = status;
+    this.wsStatus = 0;
+}
+
+Agent.prototype = {};
+Agent.prototype.constructor = Agent;
+
+/**
+ * Sets the application info in agent
+ * and triggers the update event.
+ * @param {ApplicationInfo} applicationInfoObject
+ */
+Agent.prototype.setApplicationInfo = function setApplicationInfo(applicationInfoObject) {
+    this.applicationInfo = applicationInfoObject;
+    if (NRAgent && NRAgent.config && NRAgent.config.entity_guid) {
+        this.applicationInfo.entityGuid = NRAgent.config.entity_guid;
+        this.applicationInfo.identifier.nodeId = NRAgent.config.entity_guid;
+        this.applicationInfo.identifier.id = NRAgent.config.entity_guid;
+
+        Agent.eventEmitter.emit(EVENTS.APPLICATION_INFO_UPDATE_EVENT, applicationInfoObject);
+        const logs = require('./logging');
+        const initLogger = logs.getInitLogger();
+        initLogger.info(LOG_MESSAGES.INIT_APPINFO_SEND, JSON.stringify(applicationInfoObject));
+
+    }
+
+};
+
+/**
+ * Sets the websocket client in agent
+ * and triggers the update event.
+ * @param {SecWebSocket} client
+ */
+Agent.prototype.setClient = function setClient(client) {
+    this.client = client;
+    Agent.eventEmitter.emit(EVENTS.WS_UPDATE_EVENT, client);
+};
+
+/**
+ * Sets the websocket status in agent
+ * and triggers the update event.
+ * @param {ApplicationInfo} applicationInfoObject
+ */
+Agent.prototype.setWebsocketStatus = function setWebsocketStatus(status) {
+    this.wsStatus = status;
+    Agent.eventEmitter.emit(EVENTS.WS_CONNECTION_STATUS_UPDATE_EVENT, status);
+};
+
+/**
+ * Sets the agent status in agent
+ * and triggers the update event.
+ * @param {ApplicationInfo} applicationInfoObject
+ */
+Agent.prototype.setAgentStatus = function setAgentStatus(status) {
+    this.status = status;
+    Agent.eventEmitter.emit(EVENTS.AGENT_STATUS_UPDATED_EVENT, status);
+};
+
+Agent.EVENTS = EVENTS;
+
+Agent.eventEmitter = new EventEmitter();
+
+/**
+ * This initializes a singleton agent instance.
+ *
+ * @param {ApplicationInfo} applicationInfo
+ * @param {Logger} logger
+ * @param {WebSocket} client
+ * @param {AgentStatus} status
+ */
+Agent.init = function init(applicationInfo, logger, client, status) {
+    if (!instance) {
+        instance = new Agent(applicationInfo, logger, client, status);
+    }
+};
+
+/**
+ * Returns the singleton agent instance.
+ * Returns null if init is not called.
+ *
+ * @returns {Agent} agent
+ */
+Agent.getAgent = function getAgent() {
+    return instance;
+};
+
+Agent.setNRAgent = function setNRAgent(agent) {
+    if (agent) {
+        NRAgent = agent;
+        process.env.account_id = NRAgent.config.account_id;
+        process.env.agent_run_id = NRAgent.config.run_id; 
+    }
+    const CSECAgent = Agent.getAgent();
+    if (CSECAgent) {
+        CSECAgent.applicationInfo.entityGuid = NRAgent.config.entity_guid;
+        CSECAgent.applicationInfo.linkingMetadata = LinkingMetaData.getLinkingMetadata();
+        CSECAgent.applicationInfo.linkingMetadata.agentRunId = NRAgent.config.run_id;
+        CSECAgent.setApplicationInfo(CSECAgent.applicationInfo);
+    }
+};
+
+module.exports = {
+    Agent
+};