@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Security/CheckGroup.js

@@ -0,0 +1,44 @@
+"use strict";
+
+/**
+ * A group of security checks.
+ * @interface
+ * @memberof module:SecurityCheck
+ */
+class CheckGroup {
+  constructor() {
+    this._name = this.setName();
+    this._checks = this.setChecks();
+  }
+
+  /**
+   * The security check group name; to be overridden by child class.
+   */
+  setName() {
+    throw `Check group has no name.`;
+  }
+  name() {
+    return this._name;
+  }
+
+  /**
+   * The security checks; to be overridden by child class.
+   */
+  setChecks() {
+    throw `Check group has no checks.`;
+  }
+  checks() {
+    return this._checks;
+  }
+
+  /**
+   * Runs all checks.
+   */
+  async run() {
+    for (const check of this._checks) {
+      check.run();
+    }
+  }
+}
+module.exports = CheckGroup;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Security/CheckGroups/CheckGroupDatabase.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _Check = require("../Check");
+var _CheckGroup = _interopRequireDefault(require("../CheckGroup"));
+var _Config = _interopRequireDefault(require("../../Config"));
+var _node = _interopRequireDefault(require("parse/node"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * The security checks group for Parse Server configuration.
+ * Checks common Parse Server parameters such as access keys
+ * @memberof module:SecurityCheck
+ */
+class CheckGroupDatabase extends _CheckGroup.default {
+  setName() {
+    return 'Database';
+  }
+  setChecks() {
+    const config = _Config.default.get(_node.default.applicationId);
+    const databaseAdapter = config.database.adapter;
+    const databaseUrl = databaseAdapter._uri;
+    return [new _Check.Check({
+      title: 'Secure database password',
+      warning: 'The database password is insecure and vulnerable to brute force attacks.',
+      solution: 'Choose a longer and/or more complex password with a combination of upper- and lowercase characters, numbers and special characters.',
+      check: () => {
+        const password = databaseUrl.match(/\/\/\S+:(\S+)@/)[1];
+        const hasUpperCase = /[A-Z]/.test(password);
+        const hasLowerCase = /[a-z]/.test(password);
+        const hasNumbers = /\d/.test(password);
+        const hasNonAlphasNumerics = /\W/.test(password);
+        // Ensure length
+        if (password.length < 14) {
+          throw 1;
+        }
+        // Ensure at least 3 out of 4 requirements passed
+        if (hasUpperCase + hasLowerCase + hasNumbers + hasNonAlphasNumerics < 3) {
+          throw 1;
+        }
+      }
+    })];
+  }
+}
+module.exports = CheckGroupDatabase;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Security/CheckGroups/CheckGroupServerConfig.js

@@ -0,0 +1,160 @@
+"use strict";
+
+var _Check = require("../Check");
+var _CheckGroup = _interopRequireDefault(require("../CheckGroup"));
+var _Config = _interopRequireDefault(require("../../Config"));
+var _node = _interopRequireDefault(require("parse/node"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * The security checks group for Parse Server configuration.
+ * Checks common Parse Server parameters such as access keys.
+ * @memberof module:SecurityCheck
+ */
+class CheckGroupServerConfig extends _CheckGroup.default {
+  setName() {
+    return 'Parse Server Configuration';
+  }
+  setChecks() {
+    const config = _Config.default.get(_node.default.applicationId);
+    return [new _Check.Check({
+      title: 'Secure master key',
+      warning: 'The Parse Server master key is insecure and vulnerable to brute force attacks.',
+      solution: 'Choose a longer and/or more complex master key with a combination of upper- and lowercase characters, numbers and special characters.',
+      check: () => {
+        const masterKey = config.masterKey;
+        const hasUpperCase = /[A-Z]/.test(masterKey);
+        const hasLowerCase = /[a-z]/.test(masterKey);
+        const hasNumbers = /\d/.test(masterKey);
+        const hasNonAlphasNumerics = /\W/.test(masterKey);
+        // Ensure length
+        if (masterKey.length < 14) {
+          throw 1;
+        }
+        // Ensure at least 3 out of 4 requirements passed
+        if (hasUpperCase + hasLowerCase + hasNumbers + hasNonAlphasNumerics < 3) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'Security log disabled',
+      warning: 'Security checks in logs may expose vulnerabilities to anyone with access to logs.',
+      solution: "Change Parse Server configuration to 'security.enableCheckLog: false'.",
+      check: () => {
+        if (config.security && config.security.enableCheckLog) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'Client class creation disabled',
+      warning: 'Attackers are allowed to create new classes without restriction and flood the database.',
+      solution: "Change Parse Server configuration to 'allowClientClassCreation: false'.",
+      check: () => {
+        if (config.allowClientClassCreation || config.allowClientClassCreation == null) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'Users are created without public access',
+      warning: 'Users with public read access are exposed to anyone who knows their object IDs, or to anyone who can query the Parse.User class.',
+      solution: "Change Parse Server configuration to 'enforcePrivateUsers: true'.",
+      check: () => {
+        if (!config.enforcePrivateUsers) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'Insecure auth adapters disabled',
+      warning: "Attackers may explore insecure auth adapters' vulnerabilities and log in on behalf of another user.",
+      solution: "Change Parse Server configuration to 'enableInsecureAuthAdapters: false'.",
+      check: () => {
+        if (config.enableInsecureAuthAdapters !== false) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'GraphQL public introspection disabled',
+      warning: 'GraphQL public introspection is enabled, which allows anyone to access the GraphQL schema.',
+      solution: "Change Parse Server configuration to 'graphQLPublicIntrospection: false'. You will need to use master key or maintenance key to access the GraphQL schema.",
+      check: () => {
+        if (config.graphQLPublicIntrospection !== false) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'GraphQL Playground disabled',
+      warning: 'GraphQL Playground is enabled and exposes the master key in the browser page.',
+      solution: "Change Parse Server configuration to 'mountPlayground: false'. Use Parse Dashboard for GraphQL exploration in production.",
+      check: () => {
+        if (config.mountPlayground) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'Public database explain disabled',
+      warning: 'Database explain queries are publicly accessible, which may expose sensitive database performance information and schema details.',
+      solution: "Change Parse Server configuration to 'databaseOptions.allowPublicExplain: false'. You will need to use master key to run explain queries.",
+      check: () => {
+        if (config.databaseOptions?.allowPublicExplain === true || config.databaseOptions?.allowPublicExplain == null) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'Read-only master key IP range restricted',
+      warning: 'The read-only master key can be used from any IP address, which increases the attack surface if the key is compromised.',
+      solution: "Change Parse Server configuration to 'readOnlyMasterKeyIps: [\"127.0.0.1\", \"::1\"]' to restrict access to localhost, or set it to a list of specific IP addresses.",
+      check: () => {
+        if (!config.readOnlyMasterKey) {
+          return;
+        }
+        const ips = config.readOnlyMasterKeyIps || [];
+        const wildcards = ['0.0.0.0/0', '0.0.0.0', '::/0', '::', '::0'];
+        if (ips.some(ip => wildcards.includes(ip))) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'Request complexity limits enabled',
+      warning: 'One or more request complexity limits are disabled, which may allow denial-of-service attacks through deeply nested or excessively broad queries.',
+      solution: "Ensure all properties in 'requestComplexity' are set to positive integers. Set to '-1' only if you have other mitigations in place.",
+      check: () => {
+        const rc = config.requestComplexity;
+        if (!rc) {
+          throw 1;
+        }
+        const values = [rc.includeDepth, rc.includeCount, rc.subqueryDepth, rc.queryDepth, rc.graphQLDepth, rc.graphQLFields, rc.batchRequestLimit];
+        if (values.some(v => v === -1)) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'Password reset endpoint user enumeration mitigated',
+      warning: 'The password reset endpoint returns distinct error responses for invalid email addresses, which allows attackers to enumerate registered users.',
+      solution: "Change Parse Server configuration to 'passwordPolicy.resetPasswordSuccessOnInvalidEmail: true'.",
+      check: () => {
+        if (config.passwordPolicy?.resetPasswordSuccessOnInvalidEmail === false) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'Email verification endpoint user enumeration mitigated',
+      warning: 'The email verification endpoint returns distinct error responses for invalid email addresses, which allows attackers to enumerate registered users.',
+      solution: "Change Parse Server configuration to 'emailVerifySuccessOnInvalidEmail: true'.",
+      check: () => {
+        if (config.emailVerifySuccessOnInvalidEmail === false) {
+          throw 1;
+        }
+      }
+    }), new _Check.Check({
+      title: 'LiveQuery regex timeout enabled',
+      warning: 'LiveQuery regex timeout is disabled. A malicious client can subscribe with a crafted $regex pattern that causes catastrophic backtracking, blocking the Node.js event loop and making the server unresponsive.',
+      solution: "Change Parse Server configuration to 'liveQuery.regexTimeout: 100' to set a 100ms timeout for regex evaluation in LiveQuery.",
+      check: () => {
+        if (config.liveQuery?.classNames?.length > 0 && config.liveQuery?.regexTimeout === 0) {
+          throw 1;
+        }
+      }
+    })];
+  }
+}
+module.exports = CheckGroupServerConfig;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_Check","require","_CheckGroup","_interopRequireDefault","_Config","_node","e","__esModule","default","CheckGroupServerConfig","CheckGroup","setName","setChecks","config","Config","get","Parse","applicationId","Check","title","warning","solution","check","masterKey","hasUpperCase","test","hasLowerCase","hasNumbers","hasNonAlphasNumerics","length","security","enableCheckLog","allowClientClassCreation","enforcePrivateUsers","enableInsecureAuthAdapters","graphQLPublicIntrospection","mountPlayground","databaseOptions","allowPublicExplain","readOnlyMasterKey","ips","readOnlyMasterKeyIps","wildcards","some","ip","includes","rc","requestComplexity","values","includeDepth","includeCount","subqueryDepth","queryDepth","graphQLDepth","graphQLFields","batchRequestLimit","v","passwordPolicy","resetPasswordSuccessOnInvalidEmail","emailVerifySuccessOnInvalidEmail","liveQuery","classNames","regexTimeout","module","exports"],"sources":["../../../src/Security/CheckGroups/CheckGroupServerConfig.js"],"sourcesContent":["import { Check } from '../Check';\nimport CheckGroup from '../CheckGroup';\nimport Config from '../../Config';\nimport Parse from 'parse/node';\n\n/**\n * The security checks group for Parse Server configuration.\n * Checks common Parse Server parameters such as access keys.\n * @memberof module:SecurityCheck\n */\nclass CheckGroupServerConfig extends CheckGroup {\n  setName() {\n    return 'Parse Server Configuration';\n  }\n  setChecks() {\n    const config = Config.get(Parse.applicationId);\n    return [\n      new Check({\n        title: 'Secure master key',\n        warning: 'The Parse Server master key is insecure and vulnerable to brute force attacks.',\n        solution:\n          'Choose a longer and/or more complex master key with a combination of upper- and lowercase characters, numbers and special characters.',\n        check: () => {\n          const masterKey = config.masterKey;\n          const hasUpperCase = /[A-Z]/.test(masterKey);\n          const hasLowerCase = /[a-z]/.test(masterKey);\n          const hasNumbers = /\\d/.test(masterKey);\n          const hasNonAlphasNumerics = /\\W/.test(masterKey);\n          // Ensure length\n          if (masterKey.length < 14) {\n            throw 1;\n          }\n          // Ensure at least 3 out of 4 requirements passed\n          if (hasUpperCase + hasLowerCase + hasNumbers + hasNonAlphasNumerics < 3) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'Security log disabled',\n        warning:\n          'Security checks in logs may expose vulnerabilities to anyone with access to logs.',\n        solution: \"Change Parse Server configuration to 'security.enableCheckLog: false'.\",\n        check: () => {\n          if (config.security && config.security.enableCheckLog) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'Client class creation disabled',\n        warning:\n          'Attackers are allowed to create new classes without restriction and flood the database.',\n        solution: \"Change Parse Server configuration to 'allowClientClassCreation: false'.\",\n        check: () => {\n          if (config.allowClientClassCreation || config.allowClientClassCreation == null) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'Users are created without public access',\n        warning:\n          'Users with public read access are exposed to anyone who knows their object IDs, or to anyone who can query the Parse.User class.',\n        solution: \"Change Parse Server configuration to 'enforcePrivateUsers: true'.\",\n        check: () => {\n          if (!config.enforcePrivateUsers) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'Insecure auth adapters disabled',\n        warning:\n          \"Attackers may explore insecure auth adapters' vulnerabilities and log in on behalf of another user.\",\n        solution: \"Change Parse Server configuration to 'enableInsecureAuthAdapters: false'.\",\n        check: () => {\n          if (config.enableInsecureAuthAdapters !== false) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'GraphQL public introspection disabled',\n        warning: 'GraphQL public introspection is enabled, which allows anyone to access the GraphQL schema.',\n        solution: \"Change Parse Server configuration to 'graphQLPublicIntrospection: false'. You will need to use master key or maintenance key to access the GraphQL schema.\",\n        check: () => {\n          if (config.graphQLPublicIntrospection !== false) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'GraphQL Playground disabled',\n        warning:\n          'GraphQL Playground is enabled and exposes the master key in the browser page.',\n        solution:\n          \"Change Parse Server configuration to 'mountPlayground: false'. Use Parse Dashboard for GraphQL exploration in production.\",\n        check: () => {\n          if (config.mountPlayground) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'Public database explain disabled',\n        warning:\n          'Database explain queries are publicly accessible, which may expose sensitive database performance information and schema details.',\n        solution:\n          \"Change Parse Server configuration to 'databaseOptions.allowPublicExplain: false'. You will need to use master key to run explain queries.\",\n        check: () => {\n          if (\n            config.databaseOptions?.allowPublicExplain === true ||\n            config.databaseOptions?.allowPublicExplain == null\n          ) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'Read-only master key IP range restricted',\n        warning:\n          'The read-only master key can be used from any IP address, which increases the attack surface if the key is compromised.',\n        solution:\n          \"Change Parse Server configuration to 'readOnlyMasterKeyIps: [\\\"127.0.0.1\\\", \\\"::1\\\"]' to restrict access to localhost, or set it to a list of specific IP addresses.\",\n        check: () => {\n          if (!config.readOnlyMasterKey) {\n            return;\n          }\n          const ips = config.readOnlyMasterKeyIps || [];\n          const wildcards = ['0.0.0.0/0', '0.0.0.0', '::/0', '::', '::0'];\n          if (ips.some(ip => wildcards.includes(ip))) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'Request complexity limits enabled',\n        warning:\n          'One or more request complexity limits are disabled, which may allow denial-of-service attacks through deeply nested or excessively broad queries.',\n        solution:\n          \"Ensure all properties in 'requestComplexity' are set to positive integers. Set to '-1' only if you have other mitigations in place.\",\n        check: () => {\n          const rc = config.requestComplexity;\n          if (!rc) {\n            throw 1;\n          }\n          const values = [rc.includeDepth, rc.includeCount, rc.subqueryDepth, rc.queryDepth, rc.graphQLDepth, rc.graphQLFields, rc.batchRequestLimit];\n          if (values.some(v => v === -1)) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'Password reset endpoint user enumeration mitigated',\n        warning:\n          'The password reset endpoint returns distinct error responses for invalid email addresses, which allows attackers to enumerate registered users.',\n        solution:\n          \"Change Parse Server configuration to 'passwordPolicy.resetPasswordSuccessOnInvalidEmail: true'.\",\n        check: () => {\n          if (config.passwordPolicy?.resetPasswordSuccessOnInvalidEmail === false) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'Email verification endpoint user enumeration mitigated',\n        warning:\n          'The email verification endpoint returns distinct error responses for invalid email addresses, which allows attackers to enumerate registered users.',\n        solution:\n          \"Change Parse Server configuration to 'emailVerifySuccessOnInvalidEmail: true'.\",\n        check: () => {\n          if (config.emailVerifySuccessOnInvalidEmail === false) {\n            throw 1;\n          }\n        },\n      }),\n      new Check({\n        title: 'LiveQuery regex timeout enabled',\n        warning:\n          'LiveQuery regex timeout is disabled. A malicious client can subscribe with a crafted $regex pattern that causes catastrophic backtracking, blocking the Node.js event loop and making the server unresponsive.',\n        solution:\n          \"Change Parse Server configuration to 'liveQuery.regexTimeout: 100' to set a 100ms timeout for regex evaluation in LiveQuery.\",\n        check: () => {\n          if (config.liveQuery?.classNames?.length > 0 && config.liveQuery?.regexTimeout === 0) {\n            throw 1;\n          }\n        },\n      }),\n    ];\n  }\n}\n\nmodule.exports = CheckGroupServerConfig;\n"],"mappings":"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","ignoreList":[]}

package/lib/Security/CheckGroups/CheckGroups.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CheckGroupDatabase", {
+  enumerable: true,
+  get: function () {
+    return _CheckGroupDatabase.default;
+  }
+});
+Object.defineProperty(exports, "CheckGroupServerConfig", {
+  enumerable: true,
+  get: function () {
+    return _CheckGroupServerConfig.default;
+  }
+});
+var _CheckGroupDatabase = _interopRequireDefault(require("./CheckGroupDatabase"));
+var _CheckGroupServerConfig = _interopRequireDefault(require("./CheckGroupServerConfig"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfQ2hlY2tHcm91cERhdGFiYXNlIiwiX2ludGVyb3BSZXF1aXJlRGVmYXVsdCIsInJlcXVpcmUiLCJfQ2hlY2tHcm91cFNlcnZlckNvbmZpZyIsImUiLCJfX2VzTW9kdWxlIiwiZGVmYXVsdCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9TZWN1cml0eS9DaGVja0dyb3Vwcy9DaGVja0dyb3Vwcy5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtZW1iZXJvZiBtb2R1bGU6U2VjdXJpdHlDaGVja1xuICovXG5cbi8qKlxuICogVGhlIGxpc3Qgb2Ygc2VjdXJpdHkgY2hlY2sgZ3JvdXBzLlxuICovXG5leHBvcnQgeyBkZWZhdWx0IGFzIENoZWNrR3JvdXBEYXRhYmFzZSB9IGZyb20gJy4vQ2hlY2tHcm91cERhdGFiYXNlJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgQ2hlY2tHcm91cFNlcnZlckNvbmZpZyB9IGZyb20gJy4vQ2hlY2tHcm91cFNlcnZlckNvbmZpZyc7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBT0EsSUFBQUEsbUJBQUEsR0FBQUMsc0JBQUEsQ0FBQUMsT0FBQTtBQUNBLElBQUFDLHVCQUFBLEdBQUFGLHNCQUFBLENBQUFDLE9BQUE7QUFBNkUsU0FBQUQsdUJBQUFHLENBQUEsV0FBQUEsQ0FBQSxJQUFBQSxDQUFBLENBQUFDLFVBQUEsR0FBQUQsQ0FBQSxLQUFBRSxPQUFBLEVBQUFGLENBQUEiLCJpZ25vcmVMaXN0IjpbXX0=

package/lib/Security/CheckRunner.js

@@ -0,0 +1,213 @@
+"use strict";
+
+var _Utils = _interopRequireDefault(require("../Utils"));
+var _Check = require("./Check");
+var CheckGroups = _interopRequireWildcard(require("./CheckGroups/CheckGroups"));
+var _logger = _interopRequireDefault(require("../logger"));
+var _lodash = require("lodash");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * The security check runner.
+ * @memberof module:SecurityCheck
+ */
+class CheckRunner {
+  /**
+   * The security check runner.
+   * @param {Object} [config] The configuration options.
+   * @param {Boolean} [config.enableCheck=false] Is true if Parse Server should report weak security settings.
+   * @param {Boolean} [config.enableCheckLog=false] Is true if the security check report should be written to logs.
+   * @param {Object} [config.checkGroups] The check groups to run. Default are the groups defined in `./CheckGroups/CheckGroups.js`.
+   */
+  constructor(config = {}) {
+    this._validateParams(config);
+    const {
+      enableCheck = false,
+      enableCheckLog = false,
+      checkGroups = CheckGroups
+    } = config;
+    this.enableCheck = enableCheck;
+    this.enableCheckLog = enableCheckLog;
+    this.checkGroups = checkGroups;
+  }
+
+  /**
+   * Runs all security checks and returns the results.
+   * @params
+   * @returns {Object} The security check report.
+   */
+  async run({
+    version = '1.0.0'
+  } = {}) {
+    // Instantiate check groups
+    const groups = Object.values(this.checkGroups).filter(c => typeof c === 'function').map(CheckGroup => new CheckGroup());
+
+    // Run checks
+    groups.forEach(group => group.run());
+
+    // Generate JSON report
+    const report = this._generateReport({
+      groups,
+      version
+    });
+
+    // If report should be written to logs
+    if (this.enableCheckLog) {
+      this._logReport(report);
+    }
+    return report;
+  }
+
+  /**
+   * Generates a security check report in JSON format with schema:
+   * ```
+   * {
+   *    report: {
+   *      version: "1.0.0", // The report version, defines the schema
+   *      state: "fail"     // The disjunctive indicator of failed checks in all groups.
+   *      groups: [         // The check groups
+   *        {
+   *          name: "House",            // The group name
+   *          state: "fail"             // The disjunctive indicator of failed checks in this group.
+   *          checks: [                 // The checks
+   *            title: "Door locked",   // The check title
+   *            state: "fail"           // The check state
+   *            warning: "Anyone can enter your house."   // The warning.
+   *            solution: "Lock your door."               // The solution.
+   *          ]
+   *        },
+   *        ...
+   *      ]
+   *    }
+   * }
+   * ```
+   * @param {Object} params The parameters.
+   * @param {Array<CheckGroup>} params.groups The check groups.
+   * @param {String} params.version: The report schema version.
+   * @returns {Object} The report.
+   */
+  _generateReport({
+    groups,
+    version
+  }) {
+    // Create report template
+    const report = {
+      report: {
+        version,
+        state: _Check.CheckState.success,
+        groups: []
+      }
+    };
+
+    // Identify report version
+    switch (version) {
+      case '1.0.0':
+      default:
+        // For each check group
+        for (const group of groups) {
+          // Create group report
+          const groupReport = {
+            name: group.name(),
+            state: _Check.CheckState.success,
+            checks: []
+          };
+
+          // Create check reports
+          groupReport.checks = group.checks().map(check => {
+            const checkReport = {
+              title: check.title,
+              state: check.checkState()
+            };
+            if (check.checkState() == _Check.CheckState.fail) {
+              checkReport.warning = check.warning;
+              checkReport.solution = check.solution;
+              report.report.state = _Check.CheckState.fail;
+              groupReport.state = _Check.CheckState.fail;
+            }
+            return checkReport;
+          });
+          report.report.groups.push(groupReport);
+        }
+    }
+    return report;
+  }
+
+  /**
+   * Logs the security check report.
+   * @param {Object} report The report to log.
+   */
+  _logReport(report) {
+    // Determine log level depending on whether any check failed
+    const log = report.report.state == _Check.CheckState.success ? s => _logger.default.info(s) : s => _logger.default.warn(s);
+
+    // Declare output
+    const indent = '   ';
+    let output = '';
+    let checksCount = 0;
+    let failedChecksCount = 0;
+    let skippedCheckCount = 0;
+
+    // Traverse all groups and checks for compose output
+    for (const group of report.report.groups) {
+      output += `\n- ${group.name}`;
+      for (const check of group.checks) {
+        checksCount++;
+        output += `\n${indent}${this._getLogIconForState(check.state)} ${check.title}`;
+        if (check.state == _Check.CheckState.fail) {
+          failedChecksCount++;
+          output += `\n${indent}${indent}Warning: ${check.warning}`;
+          output += ` ${check.solution}`;
+        } else if (check.state == _Check.CheckState.none) {
+          skippedCheckCount++;
+          output += `\n${indent}${indent}Test did not execute, this is likely an internal server issue, please report.`;
+        }
+      }
+    }
+    output = `\n###################################` + `\n#                                 #` + `\n#   Parse Server Security Check   #` + `\n#                                 #` + `\n###################################` + `\n` + `\n${failedChecksCount > 0 ? 'Warning: ' : ''}${failedChecksCount} weak security setting(s) found${failedChecksCount > 0 ? '!' : ''}` + `\n${checksCount} check(s) executed` + `\n${skippedCheckCount} check(s) skipped` + `\n` + `${output}`;
+
+    // Write log
+    log(output);
+  }
+
+  /**
+   * Returns an icon for use in the report log output.
+   * @param {CheckState} state The check state.
+   * @returns {String} The icon.
+   */
+  _getLogIconForState(state) {
+    switch (state) {
+      case _Check.CheckState.success:
+        return '✅';
+      case _Check.CheckState.fail:
+        return '❌';
+      default:
+        return 'ℹ️';
+    }
+  }
+
+  /**
+   * Validates the constructor parameters.
+   * @param {Object} params The parameters to validate.
+   */
+  _validateParams(params) {
+    _Utils.default.validateParams(params, {
+      enableCheck: {
+        t: 'boolean',
+        v: _lodash.isBoolean,
+        o: true
+      },
+      enableCheckLog: {
+        t: 'boolean',
+        v: _lodash.isBoolean,
+        o: true
+      },
+      checkGroups: {
+        t: 'array',
+        v: _lodash.isArray,
+        o: true
+      }
+    });
+  }
+}
+module.exports = CheckRunner;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_Utils","_interopRequireDefault","require","_Check","CheckGroups","_interopRequireWildcard","_logger","_lodash","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","CheckRunner","constructor","config","_validateParams","enableCheck","enableCheckLog","checkGroups","run","version","groups","values","filter","c","map","CheckGroup","forEach","group","report","_generateReport","_logReport","state","CheckState","success","groupReport","name","checks","check","checkReport","title","checkState","fail","warning","solution","push","log","s","logger","info","warn","indent","output","checksCount","failedChecksCount","skippedCheckCount","_getLogIconForState","none","params","Utils","validateParams","v","isBoolean","isArray","module","exports"],"sources":["../../src/Security/CheckRunner.js"],"sourcesContent":["import Utils from '../Utils';\nimport { CheckState } from './Check';\nimport * as CheckGroups from './CheckGroups/CheckGroups';\nimport logger from '../logger';\nimport { isArray, isBoolean } from 'lodash';\n\n/**\n * The security check runner.\n * @memberof module:SecurityCheck\n */\nclass CheckRunner {\n  /**\n   * The security check runner.\n   * @param {Object} [config] The configuration options.\n   * @param {Boolean} [config.enableCheck=false] Is true if Parse Server should report weak security settings.\n   * @param {Boolean} [config.enableCheckLog=false] Is true if the security check report should be written to logs.\n   * @param {Object} [config.checkGroups] The check groups to run. Default are the groups defined in `./CheckGroups/CheckGroups.js`.\n   */\n  constructor(config = {}) {\n    this._validateParams(config);\n    const { enableCheck = false, enableCheckLog = false, checkGroups = CheckGroups } = config;\n    this.enableCheck = enableCheck;\n    this.enableCheckLog = enableCheckLog;\n    this.checkGroups = checkGroups;\n  }\n\n  /**\n   * Runs all security checks and returns the results.\n   * @params\n   * @returns {Object} The security check report.\n   */\n  async run({ version = '1.0.0' } = {}) {\n    // Instantiate check groups\n    const groups = Object.values(this.checkGroups)\n      .filter(c => typeof c === 'function')\n      .map(CheckGroup => new CheckGroup());\n\n    // Run checks\n    groups.forEach(group => group.run());\n\n    // Generate JSON report\n    const report = this._generateReport({ groups, version });\n\n    // If report should be written to logs\n    if (this.enableCheckLog) {\n      this._logReport(report);\n    }\n    return report;\n  }\n\n  /**\n   * Generates a security check report in JSON format with schema:\n   * ```\n   * {\n   *    report: {\n   *      version: \"1.0.0\", // The report version, defines the schema\n   *      state: \"fail\"     // The disjunctive indicator of failed checks in all groups.\n   *      groups: [         // The check groups\n   *        {\n   *          name: \"House\",            // The group name\n   *          state: \"fail\"             // The disjunctive indicator of failed checks in this group.\n   *          checks: [                 // The checks\n   *            title: \"Door locked\",   // The check title\n   *            state: \"fail\"           // The check state\n   *            warning: \"Anyone can enter your house.\"   // The warning.\n   *            solution: \"Lock your door.\"               // The solution.\n   *          ]\n   *        },\n   *        ...\n   *      ]\n   *    }\n   * }\n   * ```\n   * @param {Object} params The parameters.\n   * @param {Array<CheckGroup>} params.groups The check groups.\n   * @param {String} params.version: The report schema version.\n   * @returns {Object} The report.\n   */\n  _generateReport({ groups, version }) {\n    // Create report template\n    const report = {\n      report: {\n        version,\n        state: CheckState.success,\n        groups: [],\n      },\n    };\n\n    // Identify report version\n    switch (version) {\n      case '1.0.0':\n      default:\n        // For each check group\n        for (const group of groups) {\n          // Create group report\n          const groupReport = {\n            name: group.name(),\n            state: CheckState.success,\n            checks: [],\n          };\n\n          // Create check reports\n          groupReport.checks = group.checks().map(check => {\n            const checkReport = {\n              title: check.title,\n              state: check.checkState(),\n            };\n            if (check.checkState() == CheckState.fail) {\n              checkReport.warning = check.warning;\n              checkReport.solution = check.solution;\n              report.report.state = CheckState.fail;\n              groupReport.state = CheckState.fail;\n            }\n            return checkReport;\n          });\n\n          report.report.groups.push(groupReport);\n        }\n    }\n    return report;\n  }\n\n  /**\n   * Logs the security check report.\n   * @param {Object} report The report to log.\n   */\n  _logReport(report) {\n    // Determine log level depending on whether any check failed\n    const log =\n      report.report.state == CheckState.success ? s => logger.info(s) : s => logger.warn(s);\n\n    // Declare output\n    const indent = '   ';\n    let output = '';\n    let checksCount = 0;\n    let failedChecksCount = 0;\n    let skippedCheckCount = 0;\n\n    // Traverse all groups and checks for compose output\n    for (const group of report.report.groups) {\n      output += `\\n- ${group.name}`;\n\n      for (const check of group.checks) {\n        checksCount++;\n        output += `\\n${indent}${this._getLogIconForState(check.state)} ${check.title}`;\n\n        if (check.state == CheckState.fail) {\n          failedChecksCount++;\n          output += `\\n${indent}${indent}Warning: ${check.warning}`;\n          output += ` ${check.solution}`;\n        } else if (check.state == CheckState.none) {\n          skippedCheckCount++;\n          output += `\\n${indent}${indent}Test did not execute, this is likely an internal server issue, please report.`;\n        }\n      }\n    }\n\n    output =\n      `\\n###################################` +\n      `\\n#                                 #` +\n      `\\n#   Parse Server Security Check   #` +\n      `\\n#                                 #` +\n      `\\n###################################` +\n      `\\n` +\n      `\\n${\n        failedChecksCount > 0 ? 'Warning: ' : ''\n      }${failedChecksCount} weak security setting(s) found${failedChecksCount > 0 ? '!' : ''}` +\n      `\\n${checksCount} check(s) executed` +\n      `\\n${skippedCheckCount} check(s) skipped` +\n      `\\n` +\n      `${output}`;\n\n    // Write log\n    log(output);\n  }\n\n  /**\n   * Returns an icon for use in the report log output.\n   * @param {CheckState} state The check state.\n   * @returns {String} The icon.\n   */\n  _getLogIconForState(state) {\n    switch (state) {\n      case CheckState.success:\n        return '✅';\n      case CheckState.fail:\n        return '❌';\n      default:\n        return 'ℹ️';\n    }\n  }\n\n  /**\n   * Validates the constructor parameters.\n   * @param {Object} params The parameters to validate.\n   */\n  _validateParams(params) {\n    Utils.validateParams(params, {\n      enableCheck: { t: 'boolean', v: isBoolean, o: true },\n      enableCheckLog: { t: 'boolean', v: isBoolean, o: true },\n      checkGroups: { t: 'array', v: isArray, o: true },\n    });\n  }\n}\n\nmodule.exports = CheckRunner;\n"],"mappings":"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","ignoreList":[]}

package/lib/SharedRest.js

@@ -0,0 +1,34 @@
+"use strict";
+
+const classesWithMasterOnlyAccess = ['_JobStatus', '_PushStatus', '_Hooks', '_GlobalConfig', '_GraphQLConfig', '_JobSchedule', '_Audience', '_Idempotency'];
+const {
+  createSanitizedError
+} = require('./Error');
+
+// Disallowing access to the _Role collection except by master key
+function enforceRoleSecurity(method, className, auth, config) {
+  if (className === '_Installation' && !auth.isMaster && !auth.isMaintenance) {
+    if (method === 'delete' || method === 'find') {
+      throw createSanitizedError(Parse.Error.OPERATION_FORBIDDEN, `Clients aren't allowed to perform the ${method} operation on the installation collection.`, config);
+    }
+  }
+
+  //all volatileClasses are masterKey only
+  if (classesWithMasterOnlyAccess.indexOf(className) >= 0 && !auth.isMaster && !auth.isMaintenance) {
+    throw createSanitizedError(Parse.Error.OPERATION_FORBIDDEN, `Clients aren't allowed to perform the ${method} operation on the ${className} collection.`, config);
+  }
+
+  // _Join tables are internal and must only be modified through relation operations
+  if (className.startsWith('_Join:') && !auth.isMaster && !auth.isMaintenance) {
+    throw createSanitizedError(Parse.Error.OPERATION_FORBIDDEN, `Clients aren't allowed to perform the ${method} operation on the ${className} collection.`, config);
+  }
+
+  // readOnly masterKey is not allowed
+  if (auth.isReadOnly && (method === 'delete' || method === 'create' || method === 'update')) {
+    throw createSanitizedError(Parse.Error.OPERATION_FORBIDDEN, `read-only masterKey isn't allowed to perform the ${method} operation.`, config);
+  }
+}
+module.exports = {
+  enforceRoleSecurity
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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