@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Adapters/Auth/gcenter.js

@@ -0,0 +1,217 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _crypto = _interopRequireDefault(require("crypto"));
+var _nodeForge = require("node-forge");
+var _AuthAdapter = _interopRequireDefault(require("./AuthAdapter"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Parse Server authentication adapter for Apple Game Center.
+ *
+ * @class AppleGameCenterAdapter
+ * @param {Object} options - Configuration options for the adapter.
+ * @param {string} options.bundleId - Your Apple Game Center bundle ID. Required for secure authentication.
+ * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).
+ *
+ * @param {Object} authData - The authentication data provided by the client.
+ * @param {string} authData.id - The user ID obtained from Apple Game Center.
+ * @param {string} authData.publicKeyUrl - The public key URL obtained from Apple Game Center.
+ * @param {string} authData.timestamp - The timestamp obtained from Apple Game Center.
+ * @param {string} authData.signature - The signature obtained from Apple Game Center.
+ * @param {string} authData.salt - The salt obtained from Apple Game Center.
+ * @param {string} [authData.bundleId] - **[DEPRECATED]** The bundle ID obtained from Apple Game Center (required for insecure authentication).
+ *
+ * @description
+ * ## Parse Server Configuration
+ * The following `authData` fields are required:
+ * `id`, `publicKeyUrl`, `timestamp`, `signature`, and `salt`. These fields are validated against the configured `bundleId` for additional security.
+ *
+ * To configure Parse Server for Apple Game Center authentication, use the following structure:
+ * ```json
+ * {
+ *  "auth": {
+ *    "gcenter": {
+ *     "bundleId": "com.valid.app"
+ *  }
+ * }
+ * ```
+ *
+ * ## Insecure Authentication (Not Recommended)
+ * The following `authData` fields are required for insecure authentication:
+ * `id`, `publicKeyUrl`, `timestamp`, `signature`, `salt`, and `bundleId` (**[DEPRECATED]**). This flow is insecure and poses potential security risks.
+ *
+ * To configure Parse Server for insecure authentication, use the following structure:
+ * ```json
+ * {
+ *   "auth": {
+ *    "gcenter": {
+ *      "enableInsecureAuth": true
+ *   }
+ * }
+ * ```
+ *
+ * ### Deprecation Notice
+ * The `enableInsecureAuth` option and `authData.bundleId` parameter are deprecated and may be removed in future releases. Use secure authentication with the `bundleId` configured in the `options` object instead.
+ *
+ *
+ * @example <caption>Secure Authentication Example</caption>
+ * // Example authData for secure authentication:
+ * const authData = {
+ *   gcenter: {
+ *     id: "1234567",
+ *     publicKeyUrl: "https://valid.apple.com/public/timeout.cer",
+ *     timestamp: 1460981421303,
+ *     salt: "saltST==",
+ *     signature: "PoDwf39DCN464B49jJCU0d9Y0J"
+ *   }
+ * };
+ *
+ * @example <caption>Insecure Authentication Example (Not Recommended)</caption>
+ * // Example authData for insecure authentication:
+ * const authData = {
+ *   gcenter: {
+ *     id: "1234567",
+ *     publicKeyUrl: "https://valid.apple.com/public/timeout.cer",
+ *     timestamp: 1460981421303,
+ *     salt: "saltST==",
+ *     signature: "PoDwf39DCN464B49jJCU0d9Y0J",
+ *     bundleId: "com.valid.app" // Deprecated.
+ *   }
+ * };
+ *
+ * @see {@link https://developer.apple.com/documentation/gamekit/gklocalplayer/3516283-fetchitems Apple Game Center Documentation}
+ */
+/* global BigInt */
+
+class GameCenterAuth extends _AuthAdapter.default {
+  constructor() {
+    super();
+    this.ca = {
+      cert: null,
+      url: null
+    };
+    this.cache = {};
+    this.bundleId = '';
+  }
+  validateOptions(options) {
+    if (!options) {
+      throw new Error('Game center auth options are required.');
+    }
+    if (!this.loadingPromise) {
+      this.loadingPromise = this.loadCertificate(options);
+    }
+    this.enableInsecureAuth = options.enableInsecureAuth;
+    this.bundleId = options.bundleId;
+    if (!this.enableInsecureAuth && !this.bundleId) {
+      throw new Error('bundleId is required for secure auth.');
+    }
+  }
+  async loadCertificate(options) {
+    const rootCertificateUrl = options.rootCertificateUrl || 'https://cacerts.digicert.com/DigiCertTrustedG4CodeSigningRSA4096SHA3842021CA1.crt.pem';
+    if (this.ca.url === rootCertificateUrl) {
+      return rootCertificateUrl;
+    }
+    const {
+      certificate,
+      headers
+    } = await this.fetchCertificate(rootCertificateUrl);
+    if (headers.get('content-type') !== 'application/x-pem-file' || !headers.get('content-length') || parseInt(headers.get('content-length'), 10) > 10000) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid rootCertificateURL.');
+    }
+    this.ca.cert = _nodeForge.pki.certificateFromPem(certificate);
+    this.ca.url = rootCertificateUrl;
+    return rootCertificateUrl;
+  }
+  verifyPublicKeyUrl(publicKeyUrl) {
+    const regex = /^https:\/\/(?:[-_A-Za-z0-9]+\.){0,}apple\.com\/.*\.cer$/;
+    return regex.test(publicKeyUrl);
+  }
+  async fetchCertificate(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch certificate: ${url}`);
+    }
+    const contentType = response.headers.get('content-type');
+    const isPem = contentType?.includes('application/x-pem-file');
+    if (isPem) {
+      const certificate = await response.text();
+      return {
+        certificate,
+        headers: response.headers
+      };
+    }
+    const data = await response.arrayBuffer();
+    const binaryData = Buffer.from(data);
+    const asn1Cert = _nodeForge.asn1.fromDer(binaryData.toString('binary'));
+    const forgeCert = _nodeForge.pki.certificateFromAsn1(asn1Cert);
+    const certificate = _nodeForge.pki.certificateToPem(forgeCert);
+    return {
+      certificate,
+      headers: response.headers
+    };
+  }
+  async getAppleCertificate(publicKeyUrl) {
+    if (!this.verifyPublicKeyUrl(publicKeyUrl)) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `Invalid publicKeyUrl: ${publicKeyUrl}`);
+    }
+    if (this.cache[publicKeyUrl]) {
+      return this.cache[publicKeyUrl];
+    }
+    const {
+      certificate,
+      headers
+    } = await this.fetchCertificate(publicKeyUrl);
+    const cacheControl = headers.get('cache-control');
+    const expire = cacheControl?.match(/max-age=([0-9]+)/);
+    this.verifyPublicKeyIssuer(certificate, publicKeyUrl);
+    if (expire) {
+      this.cache[publicKeyUrl] = certificate;
+      setTimeout(() => delete this.cache[publicKeyUrl], parseInt(expire[1], 10) * 1000);
+    }
+    return certificate;
+  }
+  verifyPublicKeyIssuer(cert, publicKeyUrl) {
+    const publicKeyCert = _nodeForge.pki.certificateFromPem(cert);
+    if (!this.ca.cert) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Root certificate is invalid or missing.');
+    }
+    if (!this.ca.cert.verify(publicKeyCert)) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `Invalid publicKeyUrl: ${publicKeyUrl}`);
+    }
+  }
+  verifySignature(publicKey, authData) {
+    const bundleId = this.bundleId || this.enableInsecureAuth && authData.bundleId;
+    const verifier = _crypto.default.createVerify('sha256');
+    verifier.update(Buffer.from(authData.id, 'utf8'));
+    verifier.update(Buffer.from(bundleId, 'utf8'));
+    verifier.update(this.convertTimestampToBigEndian(authData.timestamp));
+    verifier.update(Buffer.from(authData.salt, 'base64'));
+    if (!verifier.verify(publicKey, authData.signature, 'base64')) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid signature.');
+    }
+  }
+  async validateAuthData(authData) {
+    const requiredKeys = ['id', 'publicKeyUrl', 'timestamp', 'signature', 'salt'];
+    if (this.enableInsecureAuth) {
+      requiredKeys.push('bundleId');
+    }
+    for (const key of requiredKeys) {
+      if (!authData[key]) {
+        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `AuthData ${key} is missing.`);
+      }
+    }
+    await this.loadingPromise;
+    const publicKey = await this.getAppleCertificate(authData.publicKeyUrl);
+    this.verifySignature(publicKey, authData);
+  }
+  convertTimestampToBigEndian(timestamp) {
+    const buffer = Buffer.alloc(8);
+    buffer.writeBigUInt64BE(BigInt(timestamp));
+    return buffer;
+  }
+}
+var _default = exports.default = new GameCenterAuth();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_crypto","_interopRequireDefault","require","_nodeForge","_AuthAdapter","e","__esModule","default","GameCenterAuth","AuthAdapter","constructor","ca","cert","url","cache","bundleId","validateOptions","options","Error","loadingPromise","loadCertificate","enableInsecureAuth","rootCertificateUrl","certificate","headers","fetchCertificate","get","parseInt","Parse","OBJECT_NOT_FOUND","pki","certificateFromPem","verifyPublicKeyUrl","publicKeyUrl","regex","test","response","fetch","ok","contentType","isPem","includes","text","data","arrayBuffer","binaryData","Buffer","from","asn1Cert","asn1","fromDer","toString","forgeCert","certificateFromAsn1","certificateToPem","getAppleCertificate","cacheControl","expire","match","verifyPublicKeyIssuer","setTimeout","publicKeyCert","verify","verifySignature","publicKey","authData","verifier","crypto","createVerify","update","id","convertTimestampToBigEndian","timestamp","salt","signature","validateAuthData","requiredKeys","push","key","buffer","alloc","writeBigUInt64BE","BigInt","_default","exports"],"sources":["../../../src/Adapters/Auth/gcenter.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Apple Game Center.\n *\n * @class AppleGameCenterAdapter\n * @param {Object} options - Configuration options for the adapter.\n * @param {string} options.bundleId - Your Apple Game Center bundle ID. Required for secure authentication.\n * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).\n *\n * @param {Object} authData - The authentication data provided by the client.\n * @param {string} authData.id - The user ID obtained from Apple Game Center.\n * @param {string} authData.publicKeyUrl - The public key URL obtained from Apple Game Center.\n * @param {string} authData.timestamp - The timestamp obtained from Apple Game Center.\n * @param {string} authData.signature - The signature obtained from Apple Game Center.\n * @param {string} authData.salt - The salt obtained from Apple Game Center.\n * @param {string} [authData.bundleId] - **[DEPRECATED]** The bundle ID obtained from Apple Game Center (required for insecure authentication).\n *\n * @description\n * ## Parse Server Configuration\n * The following `authData` fields are required:\n * `id`, `publicKeyUrl`, `timestamp`, `signature`, and `salt`. These fields are validated against the configured `bundleId` for additional security.\n *\n * To configure Parse Server for Apple Game Center authentication, use the following structure:\n * ```json\n * {\n *  \"auth\": {\n *    \"gcenter\": {\n *     \"bundleId\": \"com.valid.app\"\n *  }\n * }\n * ```\n *\n * ## Insecure Authentication (Not Recommended)\n * The following `authData` fields are required for insecure authentication:\n * `id`, `publicKeyUrl`, `timestamp`, `signature`, `salt`, and `bundleId` (**[DEPRECATED]**). This flow is insecure and poses potential security risks.\n *\n * To configure Parse Server for insecure authentication, use the following structure:\n * ```json\n * {\n *   \"auth\": {\n *    \"gcenter\": {\n *      \"enableInsecureAuth\": true\n *   }\n * }\n * ```\n *\n * ### Deprecation Notice\n * The `enableInsecureAuth` option and `authData.bundleId` parameter are deprecated and may be removed in future releases. Use secure authentication with the `bundleId` configured in the `options` object instead.\n *\n *\n * @example <caption>Secure Authentication Example</caption>\n * // Example authData for secure authentication:\n * const authData = {\n *   gcenter: {\n *     id: \"1234567\",\n *     publicKeyUrl: \"https://valid.apple.com/public/timeout.cer\",\n *     timestamp: 1460981421303,\n *     salt: \"saltST==\",\n *     signature: \"PoDwf39DCN464B49jJCU0d9Y0J\"\n *   }\n * };\n *\n * @example <caption>Insecure Authentication Example (Not Recommended)</caption>\n * // Example authData for insecure authentication:\n * const authData = {\n *   gcenter: {\n *     id: \"1234567\",\n *     publicKeyUrl: \"https://valid.apple.com/public/timeout.cer\",\n *     timestamp: 1460981421303,\n *     salt: \"saltST==\",\n *     signature: \"PoDwf39DCN464B49jJCU0d9Y0J\",\n *     bundleId: \"com.valid.app\" // Deprecated.\n *   }\n * };\n *\n * @see {@link https://developer.apple.com/documentation/gamekit/gklocalplayer/3516283-fetchitems Apple Game Center Documentation}\n */\n/* global BigInt */\n\nimport crypto from 'crypto';\nimport { asn1, pki } from 'node-forge';\nimport AuthAdapter from './AuthAdapter';\nclass GameCenterAuth extends AuthAdapter {\n  constructor() {\n    super();\n    this.ca = { cert: null, url: null };\n    this.cache = {};\n    this.bundleId = '';\n  }\n\n  validateOptions(options) {\n    if (!options) {\n      throw new Error('Game center auth options are required.');\n    }\n\n    if (!this.loadingPromise) {\n      this.loadingPromise = this.loadCertificate(options);\n    }\n\n    this.enableInsecureAuth = options.enableInsecureAuth;\n    this.bundleId = options.bundleId;\n\n    if (!this.enableInsecureAuth && !this.bundleId) {\n      throw new Error('bundleId is required for secure auth.');\n    }\n  }\n\n  async loadCertificate(options) {\n    const rootCertificateUrl =\n      options.rootCertificateUrl ||\n      'https://cacerts.digicert.com/DigiCertTrustedG4CodeSigningRSA4096SHA3842021CA1.crt.pem';\n\n    if (this.ca.url === rootCertificateUrl) {\n      return rootCertificateUrl;\n    }\n\n    const { certificate, headers } = await this.fetchCertificate(rootCertificateUrl);\n\n    if (\n      headers.get('content-type') !== 'application/x-pem-file' ||\n      !headers.get('content-length') ||\n      parseInt(headers.get('content-length'), 10) > 10000\n    ) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid rootCertificateURL.');\n    }\n\n    this.ca.cert = pki.certificateFromPem(certificate);\n    this.ca.url = rootCertificateUrl;\n\n    return rootCertificateUrl;\n  }\n\n  verifyPublicKeyUrl(publicKeyUrl) {\n    const regex = /^https:\\/\\/(?:[-_A-Za-z0-9]+\\.){0,}apple\\.com\\/.*\\.cer$/;\n    return regex.test(publicKeyUrl);\n  }\n\n  async fetchCertificate(url) {\n    const response = await fetch(url);\n    if (!response.ok) {\n      throw new Error(`Failed to fetch certificate: ${url}`);\n    }\n\n    const contentType = response.headers.get('content-type');\n    const isPem = contentType?.includes('application/x-pem-file');\n\n    if (isPem) {\n      const certificate = await response.text();\n      return { certificate, headers: response.headers };\n    }\n\n    const data = await response.arrayBuffer();\n    const binaryData = Buffer.from(data);\n\n    const asn1Cert = asn1.fromDer(binaryData.toString('binary'));\n    const forgeCert = pki.certificateFromAsn1(asn1Cert);\n    const certificate = pki.certificateToPem(forgeCert);\n\n    return { certificate, headers: response.headers };\n  }\n\n  async getAppleCertificate(publicKeyUrl) {\n    if (!this.verifyPublicKeyUrl(publicKeyUrl)) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `Invalid publicKeyUrl: ${publicKeyUrl}`);\n    }\n\n    if (this.cache[publicKeyUrl]) {\n      return this.cache[publicKeyUrl];\n    }\n\n    const { certificate, headers } = await this.fetchCertificate(publicKeyUrl);\n    const cacheControl = headers.get('cache-control');\n    const expire = cacheControl?.match(/max-age=([0-9]+)/);\n\n    this.verifyPublicKeyIssuer(certificate, publicKeyUrl);\n\n    if (expire) {\n      this.cache[publicKeyUrl] = certificate;\n      setTimeout(() => delete this.cache[publicKeyUrl], parseInt(expire[1], 10) * 1000);\n    }\n\n    return certificate;\n  }\n\n  verifyPublicKeyIssuer(cert, publicKeyUrl) {\n    const publicKeyCert = pki.certificateFromPem(cert);\n\n    if (!this.ca.cert) {\n      throw new Parse.Error(\n        Parse.Error.OBJECT_NOT_FOUND,\n        'Root certificate is invalid or missing.'\n      );\n    }\n\n    if (!this.ca.cert.verify(publicKeyCert)) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `Invalid publicKeyUrl: ${publicKeyUrl}`);\n    }\n  }\n\n  verifySignature(publicKey, authData) {\n    const bundleId = this.bundleId || (this.enableInsecureAuth && authData.bundleId);\n\n    const verifier = crypto.createVerify('sha256');\n    verifier.update(Buffer.from(authData.id, 'utf8'));\n    verifier.update(Buffer.from(bundleId, 'utf8'));\n    verifier.update(this.convertTimestampToBigEndian(authData.timestamp));\n    verifier.update(Buffer.from(authData.salt, 'base64'));\n\n    if (!verifier.verify(publicKey, authData.signature, 'base64')) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid signature.');\n    }\n  }\n\n  async validateAuthData(authData) {\n\n    const requiredKeys = ['id', 'publicKeyUrl', 'timestamp', 'signature', 'salt'];\n    if (this.enableInsecureAuth) {\n      requiredKeys.push('bundleId');\n    }\n\n    for (const key of requiredKeys) {\n      if (!authData[key]) {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `AuthData ${key} is missing.`);\n      }\n    }\n\n    await this.loadingPromise;\n\n    const publicKey = await this.getAppleCertificate(authData.publicKeyUrl);\n    this.verifySignature(publicKey, authData);\n  }\n\n  convertTimestampToBigEndian(timestamp) {\n    const buffer = Buffer.alloc(8);\n    buffer.writeBigUInt64BE(BigInt(timestamp));\n    return buffer;\n  }\n}\n\nexport default new GameCenterAuth();\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/github.js

@@ -0,0 +1,125 @@
+"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 GitHub.
+ * @class GitHubAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - The GitHub App Client ID. Required for secure authentication.
+ * @param {string} options.clientSecret - The GitHub App Client Secret. Required for secure authentication.
+ * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).
+ *
+ * @param {Object} authData - The authentication data provided by the client.
+ * @param {string} authData.code - The authorization code from GitHub. Required for secure authentication.
+ * @param {string} [authData.id] - **[DEPRECATED]** The GitHub user ID (required for insecure authentication).
+ * @param {string} [authData.access_token] - **[DEPRECATED]** The GitHub access token (required for insecure authentication).
+ *
+ * @description
+ * ## Parse Server Configuration
+ * * To configure Parse Server for GitHub authentication, use the following structure:
+ * ```json
+ * {
+ *  "auth": {
+ *   "github": {
+ *     "clientId": "12345",
+ *     "clientSecret": "abcde"
+ *   }
+ * }
+ * ```
+ *
+ * The GitHub adapter exchanges the `authData.code` provided by the client for an access token using GitHub's OAuth API. The following `authData` field is required:
+ * - `code`
+ *
+ * ## Insecure Authentication (Not Recommended)
+ * Insecure authentication uses the `authData.id` and `authData.access_token` provided by the client. This flow is insecure, deprecated, and poses potential security risks. The following `authData` fields are required:
+ * - `id` (**[DEPRECATED]**): The GitHub user ID.
+ * - `access_token` (**[DEPRECATED]**): The GitHub access token.
+ * To configure Parse Server for insecure authentication, use the following structure:
+ * ```json
+ * {
+ *  "auth": {
+ *    "github": {
+ *    "enableInsecureAuth": true
+ *  }
+ * }
+ * ```
+ *
+ * ### Deprecation Notice
+ * The `enableInsecureAuth` option and insecure `authData` fields (`id`, `access_token`) are deprecated and will be removed in future versions. Use secure authentication with `clientId` and `clientSecret`.
+ *
+ * @example <caption>Secure Authentication Example</caption>
+ * // Example authData for secure authentication:
+ * const authData = {
+ *   github: {
+ *     code: "abc123def456ghi789"
+ *   }
+ * };
+ *
+ * @example <caption>Insecure Authentication Example (Not Recommended)</caption>
+ * // Example authData for insecure authentication:
+ * const authData = {
+ *   github: {
+ *     id: "1234567",
+ *     access_token: "abc123def456ghi789" // Deprecated.
+ *   }
+ * };
+ *
+ * @note `enableInsecureAuth` will be removed in future versions. Use secure authentication with `clientId` and `clientSecret`.
+ * @note Secure authentication exchanges the `code` provided by the client for an access token using GitHub's OAuth API.
+ *
+ * @see {@link https://docs.github.com/en/developers/apps/authorizing-oauth-apps GitHub OAuth Documentation}
+ */
+
+class GitHubAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('GitHub');
+  }
+  async getAccessTokenFromCode(authData) {
+    const tokenUrl = 'https://github.com/login/oauth/access_token';
+    const response = await fetch(tokenUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+      },
+      body: JSON.stringify({
+        client_id: this.clientId,
+        client_secret: this.clientSecret,
+        code: authData.code
+      })
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `Failed to exchange code for token: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, data.error_description || data.error);
+    }
+    return data.access_token;
+  }
+  async getUserFromAccessToken(accessToken) {
+    const userApiUrl = 'https://api.github.com/user';
+    const response = await fetch(userApiUrl, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/json'
+      }
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `Failed to fetch GitHub user: ${response.statusText}`);
+    }
+    const userData = await response.json();
+    if (!userData.id || !userData.login) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'Invalid GitHub user data received.');
+    }
+    return userData;
+  }
+}
+var _default = exports.default = new GitHubAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_BaseCodeAuthAdapter","_interopRequireDefault","require","e","__esModule","default","GitHubAdapter","BaseCodeAuthAdapter","constructor","getAccessTokenFromCode","authData","tokenUrl","response","fetch","method","headers","Accept","body","JSON","stringify","client_id","clientId","client_secret","clientSecret","code","ok","Parse","Error","VALIDATION_ERROR","statusText","data","json","error","OBJECT_NOT_FOUND","error_description","access_token","getUserFromAccessToken","accessToken","userApiUrl","Authorization","userData","id","login","_default","exports"],"sources":["../../../src/Adapters/Auth/github.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for GitHub.\n * @class GitHubAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {string} options.clientId - The GitHub App Client ID. Required for secure authentication.\n * @param {string} options.clientSecret - The GitHub App Client Secret. Required for secure authentication.\n * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).\n *\n * @param {Object} authData - The authentication data provided by the client.\n * @param {string} authData.code - The authorization code from GitHub. Required for secure authentication.\n * @param {string} [authData.id] - **[DEPRECATED]** The GitHub user ID (required for insecure authentication).\n * @param {string} [authData.access_token] - **[DEPRECATED]** The GitHub access token (required for insecure authentication).\n *\n * @description\n * ## Parse Server Configuration\n * * To configure Parse Server for GitHub authentication, use the following structure:\n * ```json\n * {\n *  \"auth\": {\n *   \"github\": {\n *     \"clientId\": \"12345\",\n *     \"clientSecret\": \"abcde\"\n *   }\n * }\n * ```\n *\n * The GitHub adapter exchanges the `authData.code` provided by the client for an access token using GitHub's OAuth API. The following `authData` field is required:\n * - `code`\n *\n * ## Insecure Authentication (Not Recommended)\n * Insecure authentication uses the `authData.id` and `authData.access_token` provided by the client. This flow is insecure, deprecated, and poses potential security risks. The following `authData` fields are required:\n * - `id` (**[DEPRECATED]**): The GitHub user ID.\n * - `access_token` (**[DEPRECATED]**): The GitHub access token.\n * To configure Parse Server for insecure authentication, use the following structure:\n * ```json\n * {\n *  \"auth\": {\n *    \"github\": {\n *    \"enableInsecureAuth\": true\n *  }\n * }\n * ```\n *\n * ### Deprecation Notice\n * The `enableInsecureAuth` option and insecure `authData` fields (`id`, `access_token`) are deprecated and will be removed in future versions. Use secure authentication with `clientId` and `clientSecret`.\n *\n * @example <caption>Secure Authentication Example</caption>\n * // Example authData for secure authentication:\n * const authData = {\n *   github: {\n *     code: \"abc123def456ghi789\"\n *   }\n * };\n *\n * @example <caption>Insecure Authentication Example (Not Recommended)</caption>\n * // Example authData for insecure authentication:\n * const authData = {\n *   github: {\n *     id: \"1234567\",\n *     access_token: \"abc123def456ghi789\" // Deprecated.\n *   }\n * };\n *\n * @note `enableInsecureAuth` will be removed in future versions. Use secure authentication with `clientId` and `clientSecret`.\n * @note Secure authentication exchanges the `code` provided by the client for an access token using GitHub's OAuth API.\n *\n * @see {@link https://docs.github.com/en/developers/apps/authorizing-oauth-apps GitHub OAuth Documentation}\n */\n\nimport BaseCodeAuthAdapter from './BaseCodeAuthAdapter';\nclass GitHubAdapter extends BaseCodeAuthAdapter {\n  constructor() {\n    super('GitHub');\n  }\n  async getAccessTokenFromCode(authData) {\n    const tokenUrl = 'https://github.com/login/oauth/access_token';\n    const response = await fetch(tokenUrl, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n        Accept: 'application/json',\n      },\n      body: JSON.stringify({\n        client_id: this.clientId,\n        client_secret: this.clientSecret,\n        code: authData.code,\n      }),\n    });\n\n    if (!response.ok) {\n      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `Failed to exchange code for token: ${response.statusText}`);\n    }\n\n    const data = await response.json();\n    if (data.error) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, data.error_description || data.error);\n    }\n\n    return data.access_token;\n  }\n\n  async getUserFromAccessToken(accessToken) {\n    const userApiUrl = 'https://api.github.com/user';\n    const response = await fetch(userApiUrl, {\n      method: 'GET',\n      headers: {\n        Authorization: `Bearer ${accessToken}`,\n        Accept: 'application/json',\n      },\n    });\n\n    if (!response.ok) {\n      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `Failed to fetch GitHub user: ${response.statusText}`);\n    }\n\n    const userData = await response.json();\n    if (!userData.id || !userData.login) {\n      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'Invalid GitHub user data received.');\n    }\n\n    return userData;\n  }\n\n}\n\nexport default new GitHubAdapter();\n\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/google.js

@@ -0,0 +1,122 @@
+/**
+ * Parse Server authentication adapter for Google.
+ *
+ * @class GoogleAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - Your Google application Client ID.
+ * @param {number} [options.cacheMaxEntries] - Maximum number of JWKS cache entries. Default: 5.
+ * @param {number} [options.cacheMaxAge] - Maximum age of JWKS cache entries in ms. Default: 3600000 (1 hour).
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Google authentication, use the following structure:
+ * ```json
+ * {
+ *   "auth": {
+ *     "google": {
+ *       "clientId": "your-client-id"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - **id**: The Google user ID.
+ * - **id_token**: The Google ID token.
+ *
+ * ## Auth Payload
+ * ### Example Auth Data Payload
+ * ```json
+ * {
+ *   "google": {
+ *     "id": "1234567",
+ *     "id_token": "xxxxx.yyyyy.zzzzz"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - Ensure your Google Client ID is configured properly in the Parse Server configuration.
+ * - The `id_token` is validated against Google's authentication services.
+ *
+ * @see {@link https://developers.google.com/identity/sign-in/web/backend-auth Google Authentication Documentation}
+ */
+
+'use strict';
+
+var Parse = require('parse/node').Parse;
+const jwksClient = require('jwks-rsa');
+const jwt = require('jsonwebtoken');
+const authUtils = require('./utils');
+const TOKEN_ISSUER = 'accounts.google.com';
+const HTTPS_TOKEN_ISSUER = 'https://accounts.google.com';
+const getGoogleKeyByKeyId = async (keyId, cacheMaxEntries, cacheMaxAge) => {
+  const client = jwksClient({
+    jwksUri: 'https://www.googleapis.com/oauth2/v3/certs',
+    cache: true,
+    cacheMaxEntries,
+    cacheMaxAge
+  });
+  let key;
+  try {
+    key = await authUtils.getSigningKey(client, keyId);
+  } catch {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `Unable to find matching key for Key ID: ${keyId}`);
+  }
+  return key;
+};
+async function verifyIdToken({
+  id_token: token,
+  id
+}, {
+  clientId,
+  cacheMaxEntries,
+  cacheMaxAge
+}) {
+  if (!clientId) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Google auth is not configured.');
+  }
+  if (!token) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `id token is invalid for this user.`);
+  }
+  const {
+    kid: keyId
+  } = authUtils.getHeaderFromToken(token);
+  const ONE_HOUR_IN_MS = 3600000;
+  let jwtClaims;
+  cacheMaxAge = cacheMaxAge || ONE_HOUR_IN_MS;
+  cacheMaxEntries = cacheMaxEntries || 5;
+  const googleKey = await getGoogleKeyByKeyId(keyId, cacheMaxEntries, cacheMaxAge);
+  const signingKey = googleKey.publicKey || googleKey.rsaPublicKey;
+  try {
+    jwtClaims = jwt.verify(token, signingKey, {
+      algorithms: ['RS256'],
+      audience: clientId
+    });
+  } catch (exception) {
+    const message = exception.message;
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${message}`);
+  }
+  if (jwtClaims.iss !== TOKEN_ISSUER && jwtClaims.iss !== HTTPS_TOKEN_ISSUER) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `id token not issued by correct provider - expected: ${TOKEN_ISSUER} or ${HTTPS_TOKEN_ISSUER} | from: ${jwtClaims.iss}`);
+  }
+  if (jwtClaims.sub !== id) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `auth data is invalid for this user.`);
+  }
+  return jwtClaims;
+}
+
+// Returns a promise that fulfills if this user id is valid.
+function validateAuthData(authData, options = {}) {
+  return verifyIdToken(authData, options);
+}
+
+// Returns a promise that fulfills if this app id is valid.
+function validateAppId() {
+  return Promise.resolve();
+}
+module.exports = {
+  validateAppId: validateAppId,
+  validateAuthData: validateAuthData
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Parse","require","jwksClient","jwt","authUtils","TOKEN_ISSUER","HTTPS_TOKEN_ISSUER","getGoogleKeyByKeyId","keyId","cacheMaxEntries","cacheMaxAge","client","jwksUri","cache","key","getSigningKey","Error","OBJECT_NOT_FOUND","verifyIdToken","id_token","token","id","clientId","kid","getHeaderFromToken","ONE_HOUR_IN_MS","jwtClaims","googleKey","signingKey","publicKey","rsaPublicKey","verify","algorithms","audience","exception","message","iss","sub","validateAuthData","authData","options","validateAppId","Promise","resolve","module","exports"],"sources":["../../../src/Adapters/Auth/google.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Google.\n *\n * @class GoogleAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {string} options.clientId - Your Google application Client ID.\n * @param {number} [options.cacheMaxEntries] - Maximum number of JWKS cache entries. Default: 5.\n * @param {number} [options.cacheMaxAge] - Maximum age of JWKS cache entries in ms. Default: 3600000 (1 hour).\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for Google authentication, use the following structure:\n * ```json\n * {\n *   \"auth\": {\n *     \"google\": {\n *       \"clientId\": \"your-client-id\"\n *     }\n *   }\n * }\n * ```\n *\n * The adapter requires the following `authData` fields:\n * - **id**: The Google user ID.\n * - **id_token**: The Google ID token.\n *\n * ## Auth Payload\n * ### Example Auth Data Payload\n * ```json\n * {\n *   \"google\": {\n *     \"id\": \"1234567\",\n *     \"id_token\": \"xxxxx.yyyyy.zzzzz\"\n *   }\n * }\n * ```\n *\n * ## Notes\n * - Ensure your Google Client ID is configured properly in the Parse Server configuration.\n * - The `id_token` is validated against Google's authentication services.\n *\n * @see {@link https://developers.google.com/identity/sign-in/web/backend-auth Google Authentication Documentation}\n */\n\n'use strict';\n\nvar Parse = require('parse/node').Parse;\n\nconst jwksClient = require('jwks-rsa');\nconst jwt = require('jsonwebtoken');\nconst authUtils = require('./utils');\n\nconst TOKEN_ISSUER = 'accounts.google.com';\nconst HTTPS_TOKEN_ISSUER = 'https://accounts.google.com';\n\nconst getGoogleKeyByKeyId = async (keyId, cacheMaxEntries, cacheMaxAge) => {\n  const client = jwksClient({\n    jwksUri: 'https://www.googleapis.com/oauth2/v3/certs',\n    cache: true,\n    cacheMaxEntries,\n    cacheMaxAge,\n  });\n\n  let key;\n  try {\n    key = await authUtils.getSigningKey(client, keyId);\n  } catch {\n    throw new Parse.Error(\n      Parse.Error.OBJECT_NOT_FOUND,\n      `Unable to find matching key for Key ID: ${keyId}`\n    );\n  }\n  return key;\n};\n\nasync function verifyIdToken({ id_token: token, id }, { clientId, cacheMaxEntries, cacheMaxAge }) {\n  if (!clientId) {\n    throw new Parse.Error(\n      Parse.Error.OBJECT_NOT_FOUND,\n      'Google auth is not configured.'\n    );\n  }\n\n  if (!token) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `id token is invalid for this user.`);\n  }\n\n  const { kid: keyId } = authUtils.getHeaderFromToken(token);\n  const ONE_HOUR_IN_MS = 3600000;\n  let jwtClaims;\n\n  cacheMaxAge = cacheMaxAge || ONE_HOUR_IN_MS;\n  cacheMaxEntries = cacheMaxEntries || 5;\n\n  const googleKey = await getGoogleKeyByKeyId(keyId, cacheMaxEntries, cacheMaxAge);\n  const signingKey = googleKey.publicKey || googleKey.rsaPublicKey;\n\n  try {\n    jwtClaims = jwt.verify(token, signingKey, {\n      algorithms: ['RS256'],\n      audience: clientId,\n    });\n  } catch (exception) {\n    const message = exception.message;\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${message}`);\n  }\n\n  if (jwtClaims.iss !== TOKEN_ISSUER && jwtClaims.iss !== HTTPS_TOKEN_ISSUER) {\n    throw new Parse.Error(\n      Parse.Error.OBJECT_NOT_FOUND,\n      `id token not issued by correct provider - expected: ${TOKEN_ISSUER} or ${HTTPS_TOKEN_ISSUER} | from: ${jwtClaims.iss}`\n    );\n  }\n\n  if (jwtClaims.sub !== id) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `auth data is invalid for this user.`);\n  }\n\n  return jwtClaims;\n}\n\n// Returns a promise that fulfills if this user id is valid.\nfunction validateAuthData(authData, options = {}) {\n  return verifyIdToken(authData, options);\n}\n\n// Returns a promise that fulfills if this app id is valid.\nfunction validateAppId() {\n  return Promise.resolve();\n}\n\nmodule.exports = {\n  validateAppId: validateAppId,\n  validateAuthData: validateAuthData,\n};\n"],"mappings":"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","ignoreList":[]}