@contrast/agent 4.2.0

package/lib/reporter/translations/to-protobuf/settings/reaction.js

@@ -0,0 +1,29 @@
+/**
+Copyright: 2021 Contrast Security, Inc
+  Contact: support@contrastsecurity.com
+  License: Commercial
+
+  NOTICE: This Software and the patented inventions embodied within may only be
+  used as part of Contrast Security’s commercial offerings. Even though it is
+  made available through public repositories, use of this Software is subject to
+  the applicable End User Licensing Agreement found at
+  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
+  between Contrast Security and the End User. The Software may not be reverse
+  engineered, modified, repackaged, sold, redistributed or otherwise used in a
+  way not consistent with the End User License Agreement.
+*/
+'use strict';
+
+const { settings } = require('@contrast/protobuf-api');
+
+const { LOG_LEVEL, REACTION_OPERATION } = require('../../enums');
+
+function Reaction({ logLevel, message, operation } = {}) {
+  return new settings.Reaction([
+    message, //                      1   message
+    LOG_LEVEL[logLevel], //          2 log_level
+    REACTION_OPERATION[operation] // 3 operation
+  ]);
+}
+
+module.exports = Reaction;

package/lib/reporter/translations/to-protobuf/settings/rule-definition.js

@@ -0,0 +1,59 @@
+/**
+Copyright: 2021 Contrast Security, Inc
+  Contact: support@contrastsecurity.com
+  License: Commercial
+
+  NOTICE: This Software and the patented inventions embodied within may only be
+  used as part of Contrast Security’s commercial offerings. Even though it is
+  made available through public repositories, use of this Software is subject to
+  the applicable End User Licensing Agreement found at
+  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
+  between Contrast Security and the End User. The Software may not be reverse
+  engineered, modified, repackaged, sold, redistributed or otherwise used in a
+  way not consistent with the End User License Agreement.
+*/
+'use strict';
+
+const { settings } = require('@contrast/protobuf-api');
+const { STRING_DEFINITION_TYPE } = require('../../enums');
+const { wrapToObject } = require('../../helpers');
+
+function StringDefinition({ caseSensitive, id, rule, score, type, value }) {
+  return new settings.StringDefinition([
+    type, //               1           type
+    rule, //               2           rule
+    id, //                 3             id
+    value, //              4          value
+    caseSensitive, //      5 case_sensitive
+    score, //              6          score
+    value.toLowerCase() // 7       downcase
+  ]);
+}
+
+function toKeyword(name, definition) {
+  return Object.assign({ type: 0, rule: name }, definition);
+}
+
+function toPattern(name, definition) {
+  return Object.assign({ type: 1, rule: name }, definition);
+}
+
+function RuleDefinition({ name, keywords = [], patterns = [] } = {}) {
+  return wrapToObject(
+    new settings.RuleDefinition([
+      name, //                                                                1     name
+      keywords.map((def) => StringDefinition(toKeyword(name, def)).array), // 2 keywords
+      patterns.map((def) => StringDefinition(toPattern(name, def)).array) //  3 patterns
+    ]),
+    (definitions) => {
+      definitions.keywordsList.forEach((definition) => {
+        definition.type = STRING_DEFINITION_TYPE[definition.type];
+      });
+      definitions.patternsList.forEach((definition) => {
+        definition.type = STRING_DEFINITION_TYPE[definition.type];
+      });
+    }
+  );
+}
+
+module.exports = RuleDefinition;

package/lib/reporter/translations/to-protobuf/settings/sampling.js

@@ -0,0 +1,35 @@
+/**
+Copyright: 2021 Contrast Security, Inc
+  Contact: support@contrastsecurity.com
+  License: Commercial
+
+  NOTICE: This Software and the patented inventions embodied within may only be
+  used as part of Contrast Security’s commercial offerings. Even though it is
+  made available through public repositories, use of this Software is subject to
+  the applicable End User Licensing Agreement found at
+  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
+  between Contrast Security and the End User. The Software may not be reverse
+  engineered, modified, repackaged, sold, redistributed or otherwise used in a
+  way not consistent with the End User License Agreement.
+*/
+'use strict';
+
+const { settings } = require('@contrast/protobuf-api');
+
+function Sampling({
+  baseline,
+  enabled,
+  frequency,
+  responseFrequency,
+  window
+} = {}) {
+  return new settings.Sampling([
+    enabled, //          1            enabled
+    baseline, //         2           baseline
+    window, //           3          window_ms
+    frequency, //        4  request_frequency
+    responseFrequency // 5 response_frequency
+  ]);
+}
+
+module.exports = Sampling;

package/lib/reporter/translations/to-protobuf/settings/server-features.js

@@ -0,0 +1,73 @@
+/**
+Copyright: 2021 Contrast Security, Inc
+  Contact: support@contrastsecurity.com
+  License: Commercial
+
+  NOTICE: This Software and the patented inventions embodied within may only be
+  used as part of Contrast Security’s commercial offerings. Even though it is
+  made available through public repositories, use of this Software is subject to
+  the applicable End User Licensing Agreement found at
+  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
+  between Contrast Security and the End User. The Software may not be reverse
+  engineered, modified, repackaged, sold, redistributed or otherwise used in a
+  way not consistent with the End User License Agreement.
+*/
+'use strict';
+
+const { settings } = require('@contrast/protobuf-api');
+
+const InventoryFeatures = require('./inventory-features');
+const AssessFeatures = require('./assess-features');
+const DefendFeatures = require('./defend-features');
+const { wrapToObject } = require('../../helpers');
+const {
+  STRING_DEFINITION_TYPE,
+  SYSLOG_CONNECTION_TYPES,
+  SYSLOG_SEVERITIES
+} = require('../../enums');
+
+function ServerFeatures({
+  assessment = {},
+  defend = {},
+  inventory = {},
+  logFile,
+  logLevel,
+  useCache
+} = {}) {
+  return wrapToObject(
+    new settings.ServerFeatures([
+      useCache, //                           1                cache
+      logFile, //                            2             log_file
+      logLevel, //                           3            log_level
+      InventoryFeatures(inventory).array, // 4            inventory
+      AssessFeatures(assessment).array, //   5               assess
+      DefendFeatures(defend).array, //       6               defend
+      0 //                                   7 instrumentation_mode (0=UNDEFINED)
+    ]),
+    ServerFeatures.toObject
+  );
+}
+
+ServerFeatures.toObject = ({
+  defend: { ruleDefinitionsList, syslog } = {}
+}) => {
+  // Convert integer-valued enum fields to corresponding string values.
+  if (ruleDefinitionsList) {
+    ruleDefinitionsList.forEach(({ keywordsList, patternsList }) => {
+      keywordsList.forEach((kw) => {
+        kw.type = STRING_DEFINITION_TYPE[kw.type];
+      });
+      patternsList.forEach((p) => {
+        p.type = STRING_DEFINITION_TYPE[p.type];
+      });
+    });
+  }
+  if (syslog) {
+    syslog.connectionType = SYSLOG_CONNECTION_TYPES[syslog.connectionType];
+    syslog.severityBlocked = SYSLOG_SEVERITIES[syslog.severityBlocked];
+    syslog.severityExploited = SYSLOG_SEVERITIES[syslog.severityExploited];
+    syslog.severityProbed = SYSLOG_SEVERITIES[syslog.severityProbed];
+  }
+};
+
+module.exports = ServerFeatures;

package/lib/reporter/translations/to-protobuf/settings/syslog.js

@@ -0,0 +1,62 @@
+/**
+Copyright: 2021 Contrast Security, Inc
+  Contact: support@contrastsecurity.com
+  License: Commercial
+
+  NOTICE: This Software and the patented inventions embodied within may only be
+  used as part of Contrast Security’s commercial offerings. Even though it is
+  made available through public repositories, use of this Software is subject to
+  the applicable End User Licensing Agreement found at
+  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
+  between Contrast Security and the End User. The Software may not be reverse
+  engineered, modified, repackaged, sold, redistributed or otherwise used in a
+  way not consistent with the End User License Agreement.
+*/
+'use strict';
+
+const { settings } = require('@contrast/protobuf-api');
+
+const { wrapToObject } = require('../../helpers');
+const { SYSLOG_CONNECTION_TYPES, SYSLOG_SEVERITIES } = require('../../enums');
+
+function Syslog({
+  syslogEnabled,
+  syslogPortNumber,
+  syslogFacilityCode,
+  syslogConnectionType,
+  syslogIpAddress,
+  syslogSeverityExploited,
+  syslogSeverityBlocked,
+  syslogSeverityProbed
+} = {}) {
+  return wrapToObject(
+    new settings.Syslog([
+      syslogEnabled, //                              1            enabled
+      syslogIpAddress, //                            2         ip_address
+      syslogPortNumber, //                           3               port
+      syslogFacilityCode, //                         4      facility_code
+      SyslogConnectionType(syslogConnectionType), // 5    connection_type
+      SyslogSeverity(syslogSeverityExploited), //    6 severity_exploited
+      SyslogSeverity(syslogSeverityBlocked), //      7   severity_blocked
+      SyslogSeverity(syslogSeverityProbed) //        8    severity_probed
+    ]),
+    (obj) => {
+      // Convert integer-valued enum fields to corresponding string values.
+      obj.connectionType = SYSLOG_CONNECTION_TYPES[obj.connectionType];
+      obj.severityBlocked = SYSLOG_SEVERITIES[obj.severityBlocked];
+      obj.severityExploited = SYSLOG_SEVERITIES[obj.severityExploited];
+      obj.severityProbed = SYSLOG_SEVERITIES[obj.severityProbed];
+    }
+  );
+}
+
+function SyslogConnectionType(type) {
+  // Default to ENCRYPTED
+  return type in SYSLOG_CONNECTION_TYPES ? SYSLOG_CONNECTION_TYPES[type] : 1;
+}
+
+function SyslogSeverity(severity) {
+  return severity in SYSLOG_SEVERITIES ? SYSLOG_SEVERITIES[severity] : 0;
+}
+
+module.exports = Syslog;

package/lib/reporter/translations/to-protobuf/settings/virtual-patch.js

@@ -0,0 +1,77 @@
+/**
+Copyright: 2021 Contrast Security, Inc
+  Contact: support@contrastsecurity.com
+  License: Commercial
+
+  NOTICE: This Software and the patented inventions embodied within may only be
+  used as part of Contrast Security’s commercial offerings. Even though it is
+  made available through public repositories, use of this Software is subject to
+  the applicable End User Licensing Agreement found at
+  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
+  between Contrast Security and the End User. The Software may not be reverse
+  engineered, modified, repackaged, sold, redistributed or otherwise used in a
+  way not consistent with the End User License Agreement.
+*/
+'use strict';
+
+const { settings } = require('@contrast/protobuf-api');
+
+const {
+  VIRTUAL_PATCH_INPUT_TYPES,
+  VIRTUAL_PATCH_EVALUATIONS
+} = require('../../enums');
+const { wrapToObject } = require('../../helpers');
+
+function VirtualPatch({ name, key, headers, parameters, urls, uuid } = {}) {
+  const conditions = { headers, parameters, urls };
+
+  return wrapToObject(
+    new settings.VirtualPatch([
+      name, //                                                      1       name
+      uuid, //                                                      2       uuid
+      key, //                                                       3        key
+      undefined, //                                                 4          -
+      undefined, //                                                 5          -
+      undefined, //                                                 6          -
+      VirtualPatchConditions(conditions).map((vpc) => vpc.array) // 7 conditions
+    ]),
+    (vp) => {
+      vp.conditionsList.forEach((condition) => {
+        condition.inputType = VIRTUAL_PATCH_INPUT_TYPES[condition.inputType];
+        condition.evaluation = VIRTUAL_PATCH_EVALUATIONS[condition.evaluation];
+      });
+    }
+  );
+}
+
+function VirtualPatchCondition({ name, value, input, evaluation }) {
+  return wrapToObject(
+    new settings.VirtualPatchCondition([
+      undefined, //                            1          -
+      name, //                                 2       name
+      value, //                                3      value
+      VIRTUAL_PATCH_INPUT_TYPES[input], //     4 input_type
+      VIRTUAL_PATCH_EVALUATIONS[evaluation] // 5 evaluation
+    ]),
+    (condition) => {
+      condition.inputType = VIRTUAL_PATCH_INPUT_TYPES[condition.inputType];
+      condition.evaluation = VIRTUAL_PATCH_EVALUATIONS[condition.evaluation];
+    }
+  );
+}
+
+function VirtualPatchConditions({ headers, parameters, urls }) {
+  return [headers, parameters, urls].reduce(
+    (acc, list = []) =>
+      list.reduce((acc, condition) => {
+        acc.push(VirtualPatchCondition(condition));
+        return acc;
+      }, acc),
+    []
+  );
+}
+
+module.exports = {
+  VirtualPatch,
+  VirtualPatchCondition
+};