parse-server 2.8.4 → 8.6.2

package/lib/Adapters/Auth/mfa.js

@@ -0,0 +1,324 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _otpauth = require("otpauth");
+var _cryptoUtils = require("../../cryptoUtils");
+var _AuthAdapter = _interopRequireDefault(require("./AuthAdapter"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Parse Server authentication adapter for Multi-Factor Authentication (MFA).
+ *
+ * @class MFAAdapter
+ * @param {Object} options - The adapter options.
+ * @param {Array<String>} options.options - Supported MFA methods. Must include `"SMS"` or `"TOTP"`.
+ * @param {Number} [options.digits=6] - The number of digits for the one-time password (OTP). Must be between 4 and 10.
+ * @param {Number} [options.period=30] - The validity period of the OTP in seconds. Must be greater than 10.
+ * @param {String} [options.algorithm="SHA1"] - The algorithm used for TOTP generation. Defaults to `"SHA1"`.
+ * @param {Function} [options.sendSMS] - A callback function for sending SMS OTPs. Required if `"SMS"` is included in `options`.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for MFA, use the following structure:
+ * ```javascript
+ * {
+ *   auth: {
+ *     mfa: {
+ *       options: ["SMS", "TOTP"],
+ *       digits: 6,
+ *       period: 30,
+ *       algorithm: "SHA1",
+ *       sendSMS: (token, mobile) => {
+ *         // Send the SMS using your preferred SMS provider.
+ *         console.log(`Sending SMS to ${mobile} with token: ${token}`);
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ## MFA Methods
+ * - **SMS**:
+ *   - Requires a valid mobile number.
+ *   - Sends a one-time password (OTP) via SMS for login or verification.
+ *   - Uses the `sendSMS` callback for sending the OTP.
+ *
+ * - **TOTP**:
+ *   - Requires a secret key for setup.
+ *   - Validates the user's OTP against a time-based one-time password (TOTP) generated using the secret key.
+ *   - Supports configurable digits, period, and algorithm for TOTP generation.
+ *
+ * ## MFA Payload
+ * The adapter requires the following `authData` fields:
+ * - **For SMS-based MFA**:
+ *   - `mobile`: The user's mobile number (required for setup).
+ *   - `token`: The OTP provided by the user for login or verification.
+ * - **For TOTP-based MFA**:
+ *   - `secret`: The TOTP secret key for the user (required for setup).
+ *   - `token`: The OTP provided by the user for login or verification.
+ *
+ * ## Example Payloads
+ * ### SMS Setup Payload
+ * ```json
+ * {
+ *   "mobile": "+1234567890"
+ * }
+ * ```
+ *
+ * ### TOTP Setup Payload
+ * ```json
+ * {
+ *   "secret": "BASE32ENCODEDSECRET",
+ *   "token": "123456"
+ * }
+ * ```
+ *
+ * ### Login Payload
+ * ```json
+ * {
+ *   "token": "123456"
+ * }
+ * ```
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Time-based_One-Time_Password_algorithm Time-based One-Time Password Algorithm (TOTP)}
+ * @see {@link https://tools.ietf.org/html/rfc6238 RFC 6238: TOTP: Time-Based One-Time Password Algorithm}
+ */
+
+class MFAAdapter extends _AuthAdapter.default {
+  validateOptions(opts) {
+    const validOptions = opts.options;
+    if (!Array.isArray(validOptions)) {
+      throw 'mfa.options must be an array';
+    }
+    this.sms = validOptions.includes('SMS');
+    this.totp = validOptions.includes('TOTP');
+    if (!this.sms && !this.totp) {
+      throw 'mfa.options must include SMS or TOTP';
+    }
+    const digits = opts.digits || 6;
+    const period = opts.period || 30;
+    if (typeof digits !== 'number') {
+      throw 'mfa.digits must be a number';
+    }
+    if (typeof period !== 'number') {
+      throw 'mfa.period must be a number';
+    }
+    if (digits < 4 || digits > 10) {
+      throw 'mfa.digits must be between 4 and 10';
+    }
+    if (period < 10) {
+      throw 'mfa.period must be greater than 10';
+    }
+    const sendSMS = opts.sendSMS;
+    if (this.sms && typeof sendSMS !== 'function') {
+      throw 'mfa.sendSMS callback must be defined when using SMS OTPs';
+    }
+    this.smsCallback = sendSMS;
+    this.digits = digits;
+    this.period = period;
+    this.algorithm = opts.algorithm || 'SHA1';
+  }
+  validateSetUp(mfaData) {
+    if (mfaData.mobile && this.sms) {
+      return this.setupMobileOTP(mfaData.mobile);
+    }
+    if (this.totp) {
+      return this.setupTOTP(mfaData);
+    }
+    throw 'Invalid MFA data';
+  }
+  async validateLogin(loginData, _, req) {
+    const saveResponse = {
+      doNotSave: true
+    };
+    const token = loginData.token;
+    const auth = req.original.get('authData') || {};
+    const {
+      secret,
+      recovery,
+      mobile,
+      token: saved,
+      expiry
+    } = auth.mfa || {};
+    if (this.sms && mobile) {
+      if (token === 'request') {
+        const {
+          token: sendToken,
+          expiry
+        } = await this.sendSMS(mobile);
+        auth.mfa.token = sendToken;
+        auth.mfa.expiry = expiry;
+        req.object.set('authData', auth);
+        await req.object.save(null, {
+          useMasterKey: true
+        });
+        throw 'Please enter the token';
+      }
+      if (!saved || token !== saved) {
+        throw 'Invalid MFA token 1';
+      }
+      if (new Date() > expiry) {
+        throw 'Invalid MFA token 2';
+      }
+      delete auth.mfa.token;
+      delete auth.mfa.expiry;
+      return {
+        save: auth.mfa
+      };
+    }
+    if (this.totp) {
+      if (typeof token !== 'string') {
+        throw 'Invalid MFA token';
+      }
+      if (!secret) {
+        return saveResponse;
+      }
+      if (recovery[0] === token || recovery[1] === token) {
+        return saveResponse;
+      }
+      const totp = new _otpauth.TOTP({
+        algorithm: this.algorithm,
+        digits: this.digits,
+        period: this.period,
+        secret: _otpauth.Secret.fromBase32(secret)
+      });
+      const valid = totp.validate({
+        token
+      });
+      if (valid === null) {
+        throw 'Invalid MFA token';
+      }
+    }
+    return saveResponse;
+  }
+  async validateUpdate(authData, _, req) {
+    if (req.master) {
+      return;
+    }
+    if (authData.mobile && this.sms) {
+      if (!authData.token) {
+        throw 'MFA is already set up on this account';
+      }
+      return this.confirmSMSOTP(authData, req.original.get('authData')?.mfa || {});
+    }
+    if (this.totp) {
+      await this.validateLogin({
+        token: authData.old
+      }, null, req);
+      return this.validateSetUp(authData);
+    }
+    throw 'Invalid MFA data';
+  }
+  afterFind(authData, options, req) {
+    if (req.master) {
+      return;
+    }
+    if (this.totp && authData.secret) {
+      return {
+        status: 'enabled'
+      };
+    }
+    if (this.sms && authData.mobile) {
+      return {
+        status: 'enabled'
+      };
+    }
+    return {
+      status: 'disabled'
+    };
+  }
+  policy(req, auth) {
+    if (this.sms && auth?.pending && Object.keys(auth).length === 1) {
+      return 'default';
+    }
+    return 'additional';
+  }
+  async setupMobileOTP(mobile) {
+    const {
+      token,
+      expiry
+    } = await this.sendSMS(mobile);
+    return {
+      save: {
+        pending: {
+          [mobile]: {
+            token,
+            expiry
+          }
+        }
+      }
+    };
+  }
+  async sendSMS(mobile) {
+    if (!/^[+]*[(]{0,1}[0-9]{1,3}[)]{0,1}[-\s\./0-9]*$/g.test(mobile)) {
+      throw 'Invalid mobile number.';
+    }
+    let token = '';
+    while (token.length < this.digits) {
+      token += (0, _cryptoUtils.randomString)(10).replace(/\D/g, '');
+    }
+    token = token.substring(0, this.digits);
+    await Promise.resolve(this.smsCallback(token, mobile));
+    const expiry = new Date(new Date().getTime() + this.period * 1000);
+    return {
+      token,
+      expiry
+    };
+  }
+  async confirmSMSOTP(inputData, authData) {
+    const {
+      mobile,
+      token
+    } = inputData;
+    if (!authData.pending?.[mobile]) {
+      throw 'This number is not pending';
+    }
+    const pendingData = authData.pending[mobile];
+    if (token !== pendingData.token) {
+      throw 'Invalid MFA token';
+    }
+    if (new Date() > pendingData.expiry) {
+      throw 'Invalid MFA token';
+    }
+    delete authData.pending[mobile];
+    authData.mobile = mobile;
+    return {
+      save: authData
+    };
+  }
+  setupTOTP(mfaData) {
+    const {
+      secret,
+      token
+    } = mfaData;
+    if (!secret || !token || secret.length < 20) {
+      throw 'Invalid MFA data';
+    }
+    const totp = new _otpauth.TOTP({
+      algorithm: this.algorithm,
+      digits: this.digits,
+      period: this.period,
+      secret: _otpauth.Secret.fromBase32(secret)
+    });
+    const valid = totp.validate({
+      token
+    });
+    if (valid === null) {
+      throw 'Invalid MFA token';
+    }
+    const recovery = [(0, _cryptoUtils.randomString)(30), (0, _cryptoUtils.randomString)(30)];
+    return {
+      response: {
+        recovery: recovery.join(', ')
+      },
+      save: {
+        secret,
+        recovery
+      }
+    };
+  }
+}
+var _default = exports.default = new MFAAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_otpauth","require","_cryptoUtils","_AuthAdapter","_interopRequireDefault","e","__esModule","default","MFAAdapter","AuthAdapter","validateOptions","opts","validOptions","options","Array","isArray","sms","includes","totp","digits","period","sendSMS","smsCallback","algorithm","validateSetUp","mfaData","mobile","setupMobileOTP","setupTOTP","validateLogin","loginData","_","req","saveResponse","doNotSave","token","auth","original","get","secret","recovery","saved","expiry","mfa","sendToken","object","set","save","useMasterKey","Date","TOTP","Secret","fromBase32","valid","validate","validateUpdate","authData","master","confirmSMSOTP","old","afterFind","status","policy","pending","Object","keys","length","test","randomString","replace","substring","Promise","resolve","getTime","inputData","pendingData","response","join","_default","exports"],"sources":["../../../src/Adapters/Auth/mfa.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Multi-Factor Authentication (MFA).\n *\n * @class MFAAdapter\n * @param {Object} options - The adapter options.\n * @param {Array<String>} options.options - Supported MFA methods. Must include `\"SMS\"` or `\"TOTP\"`.\n * @param {Number} [options.digits=6] - The number of digits for the one-time password (OTP). Must be between 4 and 10.\n * @param {Number} [options.period=30] - The validity period of the OTP in seconds. Must be greater than 10.\n * @param {String} [options.algorithm=\"SHA1\"] - The algorithm used for TOTP generation. Defaults to `\"SHA1\"`.\n * @param {Function} [options.sendSMS] - A callback function for sending SMS OTPs. Required if `\"SMS\"` is included in `options`.\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for MFA, use the following structure:\n * ```javascript\n * {\n *   auth: {\n *     mfa: {\n *       options: [\"SMS\", \"TOTP\"],\n *       digits: 6,\n *       period: 30,\n *       algorithm: \"SHA1\",\n *       sendSMS: (token, mobile) => {\n *         // Send the SMS using your preferred SMS provider.\n *         console.log(`Sending SMS to ${mobile} with token: ${token}`);\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * ## MFA Methods\n * - **SMS**:\n *   - Requires a valid mobile number.\n *   - Sends a one-time password (OTP) via SMS for login or verification.\n *   - Uses the `sendSMS` callback for sending the OTP.\n *\n * - **TOTP**:\n *   - Requires a secret key for setup.\n *   - Validates the user's OTP against a time-based one-time password (TOTP) generated using the secret key.\n *   - Supports configurable digits, period, and algorithm for TOTP generation.\n *\n * ## MFA Payload\n * The adapter requires the following `authData` fields:\n * - **For SMS-based MFA**:\n *   - `mobile`: The user's mobile number (required for setup).\n *   - `token`: The OTP provided by the user for login or verification.\n * - **For TOTP-based MFA**:\n *   - `secret`: The TOTP secret key for the user (required for setup).\n *   - `token`: The OTP provided by the user for login or verification.\n *\n * ## Example Payloads\n * ### SMS Setup Payload\n * ```json\n * {\n *   \"mobile\": \"+1234567890\"\n * }\n * ```\n *\n * ### TOTP Setup Payload\n * ```json\n * {\n *   \"secret\": \"BASE32ENCODEDSECRET\",\n *   \"token\": \"123456\"\n * }\n * ```\n *\n * ### Login Payload\n * ```json\n * {\n *   \"token\": \"123456\"\n * }\n * ```\n *\n * @see {@link https://en.wikipedia.org/wiki/Time-based_One-Time_Password_algorithm Time-based One-Time Password Algorithm (TOTP)}\n * @see {@link https://tools.ietf.org/html/rfc6238 RFC 6238: TOTP: Time-Based One-Time Password Algorithm}\n */\n\nimport { TOTP, Secret } from 'otpauth';\nimport { randomString } from '../../cryptoUtils';\nimport AuthAdapter from './AuthAdapter';\nclass MFAAdapter extends AuthAdapter {\n  validateOptions(opts) {\n    const validOptions = opts.options;\n    if (!Array.isArray(validOptions)) {\n      throw 'mfa.options must be an array';\n    }\n    this.sms = validOptions.includes('SMS');\n    this.totp = validOptions.includes('TOTP');\n    if (!this.sms && !this.totp) {\n      throw 'mfa.options must include SMS or TOTP';\n    }\n    const digits = opts.digits || 6;\n    const period = opts.period || 30;\n    if (typeof digits !== 'number') {\n      throw 'mfa.digits must be a number';\n    }\n    if (typeof period !== 'number') {\n      throw 'mfa.period must be a number';\n    }\n    if (digits < 4 || digits > 10) {\n      throw 'mfa.digits must be between 4 and 10';\n    }\n    if (period < 10) {\n      throw 'mfa.period must be greater than 10';\n    }\n    const sendSMS = opts.sendSMS;\n    if (this.sms && typeof sendSMS !== 'function') {\n      throw 'mfa.sendSMS callback must be defined when using SMS OTPs';\n    }\n    this.smsCallback = sendSMS;\n    this.digits = digits;\n    this.period = period;\n    this.algorithm = opts.algorithm || 'SHA1';\n  }\n  validateSetUp(mfaData) {\n    if (mfaData.mobile && this.sms) {\n      return this.setupMobileOTP(mfaData.mobile);\n    }\n    if (this.totp) {\n      return this.setupTOTP(mfaData);\n    }\n    throw 'Invalid MFA data';\n  }\n  async validateLogin(loginData, _, req) {\n    const saveResponse = {\n      doNotSave: true,\n    };\n    const token = loginData.token;\n    const auth = req.original.get('authData') || {};\n    const { secret, recovery, mobile, token: saved, expiry } = auth.mfa || {};\n    if (this.sms && mobile) {\n      if (token === 'request') {\n        const { token: sendToken, expiry } = await this.sendSMS(mobile);\n        auth.mfa.token = sendToken;\n        auth.mfa.expiry = expiry;\n        req.object.set('authData', auth);\n        await req.object.save(null, { useMasterKey: true });\n        throw 'Please enter the token';\n      }\n      if (!saved || token !== saved) {\n        throw 'Invalid MFA token 1';\n      }\n      if (new Date() > expiry) {\n        throw 'Invalid MFA token 2';\n      }\n      delete auth.mfa.token;\n      delete auth.mfa.expiry;\n      return {\n        save: auth.mfa,\n      };\n    }\n    if (this.totp) {\n      if (typeof token !== 'string') {\n        throw 'Invalid MFA token';\n      }\n      if (!secret) {\n        return saveResponse;\n      }\n      if (recovery[0] === token || recovery[1] === token) {\n        return saveResponse;\n      }\n      const totp = new TOTP({\n        algorithm: this.algorithm,\n        digits: this.digits,\n        period: this.period,\n        secret: Secret.fromBase32(secret),\n      });\n      const valid = totp.validate({\n        token,\n      });\n      if (valid === null) {\n        throw 'Invalid MFA token';\n      }\n    }\n    return saveResponse;\n  }\n  async validateUpdate(authData, _, req) {\n    if (req.master) {\n      return;\n    }\n    if (authData.mobile && this.sms) {\n      if (!authData.token) {\n        throw 'MFA is already set up on this account';\n      }\n      return this.confirmSMSOTP(authData, req.original.get('authData')?.mfa || {});\n    }\n    if (this.totp) {\n      await this.validateLogin({ token: authData.old }, null, req);\n      return this.validateSetUp(authData);\n    }\n    throw 'Invalid MFA data';\n  }\n  afterFind(authData, options, req) {\n    if (req.master) {\n      return;\n    }\n    if (this.totp && authData.secret) {\n      return {\n        status: 'enabled',\n      };\n    }\n    if (this.sms && authData.mobile) {\n      return {\n        status: 'enabled',\n      };\n    }\n    return {\n      status: 'disabled',\n    };\n  }\n\n  policy(req, auth) {\n    if (this.sms && auth?.pending && Object.keys(auth).length === 1) {\n      return 'default';\n    }\n    return 'additional';\n  }\n\n  async setupMobileOTP(mobile) {\n    const { token, expiry } = await this.sendSMS(mobile);\n    return {\n      save: {\n        pending: {\n          [mobile]: {\n            token,\n            expiry,\n          },\n        },\n      },\n    };\n  }\n\n  async sendSMS(mobile) {\n    if (!/^[+]*[(]{0,1}[0-9]{1,3}[)]{0,1}[-\\s\\./0-9]*$/g.test(mobile)) {\n      throw 'Invalid mobile number.';\n    }\n    let token = '';\n    while (token.length < this.digits) {\n      token += randomString(10).replace(/\\D/g, '');\n    }\n    token = token.substring(0, this.digits);\n    await Promise.resolve(this.smsCallback(token, mobile));\n    const expiry = new Date(new Date().getTime() + this.period * 1000);\n    return { token, expiry };\n  }\n\n  async confirmSMSOTP(inputData, authData) {\n    const { mobile, token } = inputData;\n    if (!authData.pending?.[mobile]) {\n      throw 'This number is not pending';\n    }\n    const pendingData = authData.pending[mobile];\n    if (token !== pendingData.token) {\n      throw 'Invalid MFA token';\n    }\n    if (new Date() > pendingData.expiry) {\n      throw 'Invalid MFA token';\n    }\n    delete authData.pending[mobile];\n    authData.mobile = mobile;\n    return {\n      save: authData,\n    };\n  }\n\n  setupTOTP(mfaData) {\n    const { secret, token } = mfaData;\n    if (!secret || !token || secret.length < 20) {\n      throw 'Invalid MFA data';\n    }\n    const totp = new TOTP({\n      algorithm: this.algorithm,\n      digits: this.digits,\n      period: this.period,\n      secret: Secret.fromBase32(secret),\n    });\n    const valid = totp.validate({\n      token,\n    });\n    if (valid === null) {\n      throw 'Invalid MFA token';\n    }\n    const recovery = [randomString(30), randomString(30)];\n    return {\n      response: { recovery: recovery.join(', ') },\n      save: { secret, recovery },\n    };\n  }\n}\nexport default new MFAAdapter();\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/microsoft.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _BaseCodeAuthAdapter = _interopRequireDefault(require("./BaseCodeAuthAdapter"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Parse Server authentication adapter for Microsoft.
+ *
+ * @class MicrosoftAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - Your Microsoft App Client ID. Required for secure authentication.
+ * @param {string} options.clientSecret - Your Microsoft App Client Secret. Required for secure authentication.
+ * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Microsoft authentication, use the following structure:
+ * ### Secure Configuration
+ * ```json
+ * {
+ *   "auth": {
+ *     "microsoft": {
+ *       "clientId": "your-client-id",
+ *       "clientSecret": "your-client-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "microsoft": {
+ *       "enableInsecureAuth": true
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - **Secure Authentication**: `code`, `redirect_uri`.
+ * - **Insecure Authentication (Not Recommended)**: `id`, `access_token`.
+ *
+ * ## Auth Payloads
+ * ### Secure Authentication Payload
+ * ```json
+ * {
+ *   "microsoft": {
+ *     "code": "lmn789opq012rst345uvw",
+ *     "redirect_uri": "https://your-redirect-uri.com/callback"
+ *   }
+ * }
+ * ```
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "microsoft": {
+ *     "id": "7654321",
+ *     "access_token": "AQXNnd2hIT6z9bHFzZz2Kp1ghiMz_RtyuvwXYZ123abc"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - Secure authentication exchanges the `code` and `redirect_uri` provided by the client for an access token using Microsoft's OAuth API.
+ * - **Insecure authentication** validates the user ID and access token directly, bypassing OAuth flows (not recommended). This method is deprecated and may be removed in future versions.
+ *
+ * @see {@link https://docs.microsoft.com/en-us/graph/auth/auth-concepts Microsoft Authentication Documentation}
+ */
+
+class MicrosoftAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('Microsoft');
+  }
+  async getUserFromAccessToken(access_token) {
+    const userResponse = await fetch('https://graph.microsoft.com/v1.0/me', {
+      headers: {
+        Authorization: 'Bearer ' + access_token
+      }
+    });
+    if (!userResponse.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Microsoft API request failed.');
+    }
+    return userResponse.json();
+  }
+  async getAccessTokenFromCode(authData) {
+    const response = await fetch('https://login.microsoftonline.com/common/oauth2/v2.0/token', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: new URLSearchParams({
+        client_id: this.clientId,
+        client_secret: this.clientSecret,
+        grant_type: 'authorization_code',
+        redirect_uri: authData.redirect_uri,
+        code: authData.code
+      })
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Microsoft API request failed.');
+    }
+    const json = await response.json();
+    return json.access_token;
+  }
+}
+var _default = exports.default = new MicrosoftAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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