parse-server 2.8.4 → 8.6.2

package/lib/Adapters/Auth/facebook.js

@@ -1,57 +1,184 @@
-'use strict';
+"use strict";
 
-// Helper functions for accessing the Facebook Graph API.
-var https = require('https');
-var Parse = require('parse/node').Parse;
+/**
+ * Parse Server authentication adapter for Facebook.
+ *
+ * @class FacebookAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.appSecret - Your Facebook App Secret. Required for secure authentication.
+ * @param {string[]} options.appIds - An array of Facebook App IDs. Required for validating the app.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Facebook authentication, use the following structure:
+ * ```json
+ * {
+ *   "auth": {
+ *     "facebook": {
+ *       "appSecret": "your-app-secret",
+ *       "appIds": ["your-app-id"]
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter supports the following authentication methods:
+ * - **Standard Login**: Requires `id` and `access_token`.
+ * - **Limited Login**: Requires `id` and `token`.
+ *
+ * ## Auth Payloads
+ * ### Standard Login Payload
+ * ```json
+ * {
+ *   "facebook": {
+ *     "id": "1234567",
+ *     "access_token": "abc123def456ghi789"
+ *   }
+ * }
+ * ```
+ *
+ * ### Limited Login Payload
+ * ```json
+ * {
+ *   "facebook": {
+ *     "id": "1234567",
+ *     "token": "xxxxx.yyyyy.zzzzz"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - **Standard Login**: Use `id` and `access_token` for full functionality.
+ * - **Limited Login**: Use `id` and `token` (JWT) when tracking is opted out (e.g., via Apple's App Tracking Transparency).
+ * - Supported Parse Server versions:
+ *   - `>= 6.5.6 < 7`
+ *   - `>= 7.0.1`
+ *
+ * Secure authentication is recommended to ensure proper data protection and compliance with Facebook's guidelines.
+ *
+ * @see {@link https://developers.facebook.com/docs/facebook-login/limited-login/ Facebook Limited Login}
+ * @see {@link https://developers.facebook.com/docs/facebook-login/facebook-login-for-business/ Facebook Login for Business}
+ */
 
-// Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData) {
-  return graphRequest('me?fields=id&access_token=' + authData.access_token).then(data => {
-    if (data && data.id == authData.id) {
+// Helper functions for accessing the Facebook Graph API.
+const Parse = require('parse/node').Parse;
+const crypto = require('crypto');
+const jwksClient = require('jwks-rsa');
+const jwt = require('jsonwebtoken');
+const httpsRequest = require('./httpsRequest');
+const authUtils = require('./utils');
+const TOKEN_ISSUER = 'https://www.facebook.com';
+function getAppSecretPath(authData, options = {}) {
+  const appSecret = options.appSecret;
+  if (!appSecret) {
+    return '';
+  }
+  const appsecret_proof = crypto.createHmac('sha256', appSecret).update(authData.access_token).digest('hex');
+  return `&appsecret_proof=${appsecret_proof}`;
+}
+function validateGraphToken(authData, options) {
+  return graphRequest('me?fields=id&access_token=' + authData.access_token + getAppSecretPath(authData, options)).then(data => {
+    if (data && data.id == authData.id || process.env.TESTING && authData.id === 'test') {
       return;
     }
     throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Facebook auth is invalid for this user.');
   });
 }
-
-// Returns a promise that fulfills iff this app id is valid.
-function validateAppId(appIds, authData) {
+async function validateGraphAppId(appIds, authData, options) {
   var access_token = authData.access_token;
+  if (process.env.TESTING && access_token === 'test') {
+    return;
+  }
+  if (!Array.isArray(appIds)) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'appIds must be an array.');
+  }
   if (!appIds.length) {
     throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Facebook auth is not configured.');
   }
-  return graphRequest('app?access_token=' + access_token).then(data => {
-    if (data && appIds.indexOf(data.id) != -1) {
-      return;
-    }
+  const data = await graphRequest(`app?access_token=${access_token}${getAppSecretPath(authData, options)}`);
+  if (!data || !appIds.includes(data.id)) {
     throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Facebook auth is invalid for this user.');
+  }
+}
+const getFacebookKeyByKeyId = async (keyId, cacheMaxEntries, cacheMaxAge) => {
+  const client = jwksClient({
+    jwksUri: `${TOKEN_ISSUER}/.well-known/oauth/openid/jwks/`,
+    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;
+};
+const verifyIdToken = async ({
+  token,
+  id
+}, {
+  clientId,
+  cacheMaxEntries,
+  cacheMaxAge
+}) => {
+  if (!token) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'id token is invalid for this user.');
+  }
+  const {
+    kid: keyId,
+    alg: algorithm
+  } = authUtils.getHeaderFromToken(token);
+  const ONE_HOUR_IN_MS = 3600000;
+  let jwtClaims;
+  cacheMaxAge = cacheMaxAge || ONE_HOUR_IN_MS;
+  cacheMaxEntries = cacheMaxEntries || 5;
+  const facebookKey = await getFacebookKeyByKeyId(keyId, cacheMaxEntries, cacheMaxAge);
+  const signingKey = facebookKey.publicKey || facebookKey.rsaPublicKey;
+  try {
+    jwtClaims = jwt.verify(token, signingKey, {
+      algorithms: algorithm,
+      // the audience can be checked against a string, a regular expression or a list of strings and/or regular expressions.
+      audience: clientId
+    });
+  } catch (exception) {
+    const message = exception.message;
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${message}`);
+  }
+  if (jwtClaims.iss !== TOKEN_ISSUER) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `id token not issued by correct OpenID provider - expected: ${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 iff this user id is valid.
+function validateAuthData(authData, options) {
+  if (authData.token) {
+    return verifyIdToken(authData, options);
+  } else {
+    return validateGraphToken(authData, options);
+  }
+}
+
+// Returns a promise that fulfills iff this app id is valid.
+function validateAppId(appIds, authData, options) {
+  if (authData.token) {
+    return Promise.resolve();
+  } else {
+    return validateGraphAppId(appIds, authData, options);
+  }
 }
 
 // A promisey wrapper for FB graph requests.
 function graphRequest(path) {
-  return new Promise(function (resolve, reject) {
-    https.get('https://graph.facebook.com/' + path, function (res) {
-      var data = '';
-      res.on('data', function (chunk) {
-        data += chunk;
-      });
-      res.on('end', function () {
-        try {
-          data = JSON.parse(data);
-        } catch (e) {
-          return reject(e);
-        }
-        resolve(data);
-      });
-    }).on('error', function () {
-      reject('Failed to validate this access token with Facebook.');
-    });
-  });
+  return httpsRequest.get('https://graph.facebook.com/' + path);
 }
-
 module.exports = {
   validateAppId: validateAppId,
   validateAuthData: validateAuthData
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Parse","require","crypto","jwksClient","jwt","httpsRequest","authUtils","TOKEN_ISSUER","getAppSecretPath","authData","options","appSecret","appsecret_proof","createHmac","update","access_token","digest","validateGraphToken","graphRequest","then","data","id","process","env","TESTING","Error","OBJECT_NOT_FOUND","validateGraphAppId","appIds","Array","isArray","length","includes","getFacebookKeyByKeyId","keyId","cacheMaxEntries","cacheMaxAge","client","jwksUri","cache","key","getSigningKey","verifyIdToken","token","clientId","kid","alg","algorithm","getHeaderFromToken","ONE_HOUR_IN_MS","jwtClaims","facebookKey","signingKey","publicKey","rsaPublicKey","verify","algorithms","audience","exception","message","iss","sub","validateAuthData","validateAppId","Promise","resolve","path","get","module","exports"],"sources":["../../../src/Adapters/Auth/facebook.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Facebook.\n *\n * @class FacebookAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {string} options.appSecret - Your Facebook App Secret. Required for secure authentication.\n * @param {string[]} options.appIds - An array of Facebook App IDs. Required for validating the app.\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for Facebook authentication, use the following structure:\n * ```json\n * {\n *   \"auth\": {\n *     \"facebook\": {\n *       \"appSecret\": \"your-app-secret\",\n *       \"appIds\": [\"your-app-id\"]\n *     }\n *   }\n * }\n * ```\n *\n * The adapter supports the following authentication methods:\n * - **Standard Login**: Requires `id` and `access_token`.\n * - **Limited Login**: Requires `id` and `token`.\n *\n * ## Auth Payloads\n * ### Standard Login Payload\n * ```json\n * {\n *   \"facebook\": {\n *     \"id\": \"1234567\",\n *     \"access_token\": \"abc123def456ghi789\"\n *   }\n * }\n * ```\n *\n * ### Limited Login Payload\n * ```json\n * {\n *   \"facebook\": {\n *     \"id\": \"1234567\",\n *     \"token\": \"xxxxx.yyyyy.zzzzz\"\n *   }\n * }\n * ```\n *\n * ## Notes\n * - **Standard Login**: Use `id` and `access_token` for full functionality.\n * - **Limited Login**: Use `id` and `token` (JWT) when tracking is opted out (e.g., via Apple's App Tracking Transparency).\n * - Supported Parse Server versions:\n *   - `>= 6.5.6 < 7`\n *   - `>= 7.0.1`\n *\n * Secure authentication is recommended to ensure proper data protection and compliance with Facebook's guidelines.\n *\n * @see {@link https://developers.facebook.com/docs/facebook-login/limited-login/ Facebook Limited Login}\n * @see {@link https://developers.facebook.com/docs/facebook-login/facebook-login-for-business/ Facebook Login for Business}\n */\n\n// Helper functions for accessing the Facebook Graph API.\nconst Parse = require('parse/node').Parse;\nconst crypto = require('crypto');\nconst jwksClient = require('jwks-rsa');\nconst jwt = require('jsonwebtoken');\nconst httpsRequest = require('./httpsRequest');\nconst authUtils = require('./utils');\n\nconst TOKEN_ISSUER = 'https://www.facebook.com';\n\nfunction getAppSecretPath(authData, options = {}) {\n  const appSecret = options.appSecret;\n  if (!appSecret) {\n    return '';\n  }\n  const appsecret_proof = crypto\n    .createHmac('sha256', appSecret)\n    .update(authData.access_token)\n    .digest('hex');\n\n  return `&appsecret_proof=${appsecret_proof}`;\n}\n\nfunction validateGraphToken(authData, options) {\n  return graphRequest(\n    'me?fields=id&access_token=' + authData.access_token + getAppSecretPath(authData, options)\n  ).then(data => {\n    if ((data && data.id == authData.id) || (process.env.TESTING && authData.id === 'test')) {\n      return;\n    }\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Facebook auth is invalid for this user.');\n  });\n}\n\nasync function validateGraphAppId(appIds, authData, options) {\n  var access_token = authData.access_token;\n  if (process.env.TESTING && access_token === 'test') {\n    return;\n  }\n  if (!Array.isArray(appIds)) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'appIds must be an array.');\n  }\n  if (!appIds.length) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Facebook auth is not configured.');\n  }\n  const data = await graphRequest(\n    `app?access_token=${access_token}${getAppSecretPath(authData, options)}`\n  );\n  if (!data || !appIds.includes(data.id)) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Facebook auth is invalid for this user.');\n  }\n}\n\nconst getFacebookKeyByKeyId = async (keyId, cacheMaxEntries, cacheMaxAge) => {\n  const client = jwksClient({\n    jwksUri: `${TOKEN_ISSUER}/.well-known/oauth/openid/jwks/`,\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\nconst verifyIdToken = async ({ token, id }, { clientId, cacheMaxEntries, cacheMaxAge }) => {\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, alg: algorithm } = 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 facebookKey = await getFacebookKeyByKeyId(keyId, cacheMaxEntries, cacheMaxAge);\n  const signingKey = facebookKey.publicKey || facebookKey.rsaPublicKey;\n\n  try {\n    jwtClaims = jwt.verify(token, signingKey, {\n      algorithms: algorithm,\n      // the audience can be checked against a string, a regular expression or a list of strings and/or regular expressions.\n      audience: clientId,\n    });\n  } catch (exception) {\n    const message = exception.message;\n\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${message}`);\n  }\n\n  if (jwtClaims.iss !== TOKEN_ISSUER) {\n    throw new Parse.Error(\n      Parse.Error.OBJECT_NOT_FOUND,\n      `id token not issued by correct OpenID provider - expected: ${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  return jwtClaims;\n};\n\n// Returns a promise that fulfills iff this user id is valid.\nfunction validateAuthData(authData, options) {\n  if (authData.token) {\n    return verifyIdToken(authData, options);\n  } else {\n    return validateGraphToken(authData, options);\n  }\n}\n\n// Returns a promise that fulfills iff this app id is valid.\nfunction validateAppId(appIds, authData, options) {\n  if (authData.token) {\n    return Promise.resolve();\n  } else {\n    return validateGraphAppId(appIds, authData, options);\n  }\n}\n\n// A promisey wrapper for FB graph requests.\nfunction graphRequest(path) {\n  return httpsRequest.get('https://graph.facebook.com/' + path);\n}\n\nmodule.exports = {\n  validateAppId: validateAppId,\n  validateAuthData: validateAuthData,\n};\n"],"mappings":"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","ignoreList":[]}

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":[]}