@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Adapters/Auth/janraincapture.js

@@ -0,0 +1,85 @@
+"use strict";
+
+/**
+ * Parse Server authentication adapter for Janrain Capture API.
+ *
+ * @class JanrainCapture
+ * @param {Object} options - The adapter configuration options.
+ * @param {String} options.janrain_capture_host - The Janrain Capture API host.
+ *
+ * @param {Object} authData - The authentication data provided by the client.
+ * @param {String} authData.id - The Janrain Capture user ID.
+ * @param {String} authData.access_token - The Janrain Capture access token.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Janrain Capture authentication, use the following structure:
+ * ```json
+ * {
+ *   "auth": {
+ *     "janrain": {
+ *       "janrain_capture_host": "your-janrain-capture-host"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - `id`: The Janrain Capture user ID.
+ * - `access_token`: An authorized Janrain Capture access token for the user.
+ *
+ * ## Auth Payload Example
+ * ```json
+ * {
+ *   "janrain": {
+ *     "id": "user's Janrain Capture ID as a string",
+ *     "access_token": "an authorized Janrain Capture access token for the user"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * Parse Server validates the provided `authData` using the Janrain Capture API.
+ *
+ * @see {@link https://docs.janrain.com/api/registration/entity/#entity Janrain Capture API Documentation}
+ */
+
+// Helper functions for accessing the Janrain Capture API.
+var Parse = require('parse/node').Parse;
+var querystring = require('querystring');
+const httpsRequest = require('./httpsRequest');
+
+// Returns a promise that fulfills iff this user id is valid.
+function validateAuthData(authData, options) {
+  return request(options.janrain_capture_host, authData.access_token).then(data => {
+    //successful response will have a "stat" (status) of 'ok' and a result node that stores the uuid, because that's all we asked for
+    //see: https://docs.janrain.com/api/registration/entity/#entity
+    if (data && data.stat == 'ok' && data.result == authData.id) {
+      return;
+    }
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Janrain capture auth is invalid for this user.');
+  });
+}
+
+// Returns a promise that fulfills iff this app id is valid.
+function validateAppId() {
+  //no-op
+  return Promise.resolve();
+}
+
+// A promisey wrapper for api requests
+function request(host, access_token) {
+  var query_string_data = querystring.stringify({
+    access_token: access_token,
+    attribute_name: 'uuid' // we only need to pull the uuid for this access token to make sure it matches
+  });
+  return httpsRequest.get({
+    host: host,
+    path: '/entity?' + query_string_data
+  });
+}
+module.exports = {
+  validateAppId: validateAppId,
+  validateAuthData: validateAuthData
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/janrainengage.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _Config = _interopRequireDefault(require("../../Config"));
+var _Deprecator = _interopRequireDefault(require("../../Deprecator/Deprecator"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Helper functions for accessing the Janrain Engage API.
+var httpsRequest = require('./httpsRequest');
+var Parse = require('parse/node').Parse;
+var querystring = require('querystring');
+// Returns a promise that fulfills iff this user id is valid.
+function validateAuthData(authData, options) {
+  const config = _Config.default.get(Parse.applicationId);
+  _Deprecator.default.logRuntimeDeprecation({
+    usage: 'janrainengage adapter'
+  });
+  if (!config?.auth?.janrainengage?.enableInsecureAuth || !config.enableInsecureAuthAdapters) {
+    throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'janrainengage adapter only works with enableInsecureAuth: true');
+  }
+  return apiRequest(options.api_key, authData.auth_token).then(data => {
+    //successful response will have a "stat" (status) of 'ok' and a profile node with an identifier
+    //see: http://developers.janrain.com/overview/social-login/identity-providers/user-profile-data/#normalized-user-profile-data
+    if (data && data.stat == 'ok' && data.profile.identifier == authData.id) {
+      return;
+    }
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Janrain engage auth is invalid for this user.');
+  });
+}
+
+// Returns a promise that fulfills iff this app id is valid.
+function validateAppId() {
+  //no-op
+  return Promise.resolve();
+}
+
+// A promisey wrapper for api requests
+function apiRequest(api_key, auth_token) {
+  var post_data = querystring.stringify({
+    token: auth_token,
+    apiKey: api_key,
+    format: 'json'
+  });
+  var post_options = {
+    host: 'rpxnow.com',
+    path: '/api/v2/auth_info',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+      'Content-Length': post_data.length
+    }
+  };
+  return httpsRequest.request(post_options, post_data);
+}
+module.exports = {
+  validateAppId: validateAppId,
+  validateAuthData: validateAuthData
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/keycloak.js

@@ -0,0 +1,168 @@
+"use strict";
+
+/**
+ * Parse Server authentication adapter for Keycloak.
+ *
+ * @class KeycloakAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {Object} options.config - The Keycloak configuration object, typically loaded from a JSON file.
+ * @param {String} options.config.auth-server-url - The Keycloak authentication server URL.
+ * @param {String} options.config.realm - The Keycloak realm name.
+ * @param {String} options.config.client-id - The Keycloak client ID.
+ *
+ * @param {Object} authData - The authentication data provided by the client.
+ * @param {String} authData.access_token - The Keycloak access token retrieved during client authentication.
+ * @param {String} authData.id - The user ID retrieved from Keycloak during client authentication.
+ * @param {Array} [authData.roles] - The roles assigned to the user in Keycloak (optional).
+ * @param {Array} [authData.groups] - The groups assigned to the user in Keycloak (optional).
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Keycloak authentication, use the following structure:
+ * ```javascript
+ * {
+ *   "auth": {
+ *     "keycloak": {
+ *       "config": require('./auth/keycloak.json')
+ *     }
+ *   }
+ * }
+ * ```
+ * Ensure the `keycloak.json` configuration file is generated from Keycloak's setup guide and includes:
+ * - `auth-server-url`: The Keycloak authentication server URL.
+ * - `realm`: The Keycloak realm name.
+ * - `client-id`: The Keycloak client ID.
+ *
+ * ## Auth Data
+ * The adapter requires the following `authData` fields:
+ * - `access_token`: The Keycloak access token retrieved during client authentication.
+ * - `id`: The user ID retrieved from Keycloak during client authentication.
+ * - `roles` (optional): The roles assigned to the user in Keycloak.
+ * - `groups` (optional): The groups assigned to the user in Keycloak.
+ *
+ * ## Auth Payload Example
+ * ### Example Auth Data
+ * ```json
+ * {
+ *   "keycloak": {
+ *     "access_token": "an authorized Keycloak access token for the user",
+ *     "id": "user's Keycloak ID as a string",
+ *     "roles": ["admin", "user"],
+ *     "groups": ["group1", "group2"]
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - Parse Server validates the provided `authData` by making a `userinfo` call to Keycloak and ensures the attributes match those returned by Keycloak.
+ *
+ * ## Keycloak Configuration
+ * To configure Keycloak, copy the JSON configuration file generated from Keycloak's setup guide:
+ * - [Keycloak Securing Apps Documentation](https://www.keycloak.org/docs/latest/securing_apps/index.html#_javascript_adapter)
+ *
+ * Place the configuration file on your server, for example:
+ * - `auth/keycloak.json`
+ *
+ * For more information on Keycloak authentication, see:
+ * - [Securing Apps Documentation](https://www.keycloak.org/docs/latest/securing_apps/)
+ * - [Server Administration Documentation](https://www.keycloak.org/docs/latest/server_admin/)
+ */
+
+const {
+  Parse
+} = require('parse/node');
+const jwksClient = require('jwks-rsa');
+const jwt = require('jsonwebtoken');
+const authUtils = require('./utils');
+const arraysEqual = (_arr1, _arr2) => {
+  if (!Array.isArray(_arr1) || !Array.isArray(_arr2) || _arr1.length !== _arr2.length) {
+    return false;
+  }
+  var arr1 = _arr1.concat().sort();
+  var arr2 = _arr2.concat().sort();
+  for (var i = 0; i < arr1.length; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+const getKeycloakKeyByKeyId = async (keyId, jwksUri, cacheMaxEntries, cacheMaxAge) => {
+  const client = jwksClient({
+    jwksUri,
+    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 verifyAccessToken = async ({
+  access_token,
+  id,
+  roles,
+  groups
+} = {}, {
+  config,
+  cacheMaxEntries,
+  cacheMaxAge
+} = {}) => {
+  if (!(access_token && id)) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Missing access token and/or User id');
+  }
+  if (!config || !(config['auth-server-url'] && config['realm'])) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Missing keycloak configuration');
+  }
+  if (!config['client-id']) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Keycloak auth is not configured. Missing client-id.');
+  }
+  const expectedIssuer = `${config['auth-server-url']}/realms/${config['realm']}`;
+  const jwksUri = `${config['auth-server-url']}/realms/${config['realm']}/protocol/openid-connect/certs`;
+  const {
+    kid: keyId
+  } = authUtils.getHeaderFromToken(access_token);
+  const ONE_HOUR_IN_MS = 3600000;
+  cacheMaxAge = cacheMaxAge || ONE_HOUR_IN_MS;
+  cacheMaxEntries = cacheMaxEntries || 5;
+  const keycloakKey = await getKeycloakKeyByKeyId(keyId, jwksUri, cacheMaxEntries, cacheMaxAge);
+  const signingKey = keycloakKey.publicKey || keycloakKey.rsaPublicKey;
+  let jwtClaims;
+  try {
+    jwtClaims = jwt.verify(access_token, signingKey, {
+      algorithms: ['RS256']
+    });
+  } catch (exception) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${exception.message}`);
+  }
+  if (jwtClaims.iss !== expectedIssuer) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `access token not issued by correct provider - expected: ${expectedIssuer} | from: ${jwtClaims.iss}`);
+  }
+  if (jwtClaims.azp !== config['client-id']) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `access token is not authorized for this client - expected: ${config['client-id']} | from: ${jwtClaims.azp}`);
+  }
+  if (jwtClaims.sub !== id) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'auth data is invalid for this user.');
+  }
+  const rolesMatch = jwtClaims.roles === roles || arraysEqual(jwtClaims.roles, roles);
+  const groupsMatch = jwtClaims.groups === groups || arraysEqual(jwtClaims.groups, groups);
+  if (!rolesMatch || !groupsMatch) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid authentication');
+  }
+  return jwtClaims;
+};
+function validateAuthData(authData, options = {}) {
+  return verifyAccessToken(authData, options);
+}
+function validateAppId() {
+  return Promise.resolve();
+}
+module.exports = {
+  validateAppId,
+  validateAuthData
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Parse","require","jwksClient","jwt","authUtils","arraysEqual","_arr1","_arr2","Array","isArray","length","arr1","concat","sort","arr2","i","getKeycloakKeyByKeyId","keyId","jwksUri","cacheMaxEntries","cacheMaxAge","client","cache","key","getSigningKey","Error","OBJECT_NOT_FOUND","verifyAccessToken","access_token","id","roles","groups","config","expectedIssuer","kid","getHeaderFromToken","ONE_HOUR_IN_MS","keycloakKey","signingKey","publicKey","rsaPublicKey","jwtClaims","verify","algorithms","exception","message","iss","azp","sub","rolesMatch","groupsMatch","validateAuthData","authData","options","validateAppId","Promise","resolve","module","exports"],"sources":["../../../src/Adapters/Auth/keycloak.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Keycloak.\n *\n * @class KeycloakAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {Object} options.config - The Keycloak configuration object, typically loaded from a JSON file.\n * @param {String} options.config.auth-server-url - The Keycloak authentication server URL.\n * @param {String} options.config.realm - The Keycloak realm name.\n * @param {String} options.config.client-id - The Keycloak client ID.\n *\n * @param {Object} authData - The authentication data provided by the client.\n * @param {String} authData.access_token - The Keycloak access token retrieved during client authentication.\n * @param {String} authData.id - The user ID retrieved from Keycloak during client authentication.\n * @param {Array} [authData.roles] - The roles assigned to the user in Keycloak (optional).\n * @param {Array} [authData.groups] - The groups assigned to the user in Keycloak (optional).\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for Keycloak authentication, use the following structure:\n * ```javascript\n * {\n *   \"auth\": {\n *     \"keycloak\": {\n *       \"config\": require('./auth/keycloak.json')\n *     }\n *   }\n * }\n * ```\n * Ensure the `keycloak.json` configuration file is generated from Keycloak's setup guide and includes:\n * - `auth-server-url`: The Keycloak authentication server URL.\n * - `realm`: The Keycloak realm name.\n * - `client-id`: The Keycloak client ID.\n *\n * ## Auth Data\n * The adapter requires the following `authData` fields:\n * - `access_token`: The Keycloak access token retrieved during client authentication.\n * - `id`: The user ID retrieved from Keycloak during client authentication.\n * - `roles` (optional): The roles assigned to the user in Keycloak.\n * - `groups` (optional): The groups assigned to the user in Keycloak.\n *\n * ## Auth Payload Example\n * ### Example Auth Data\n * ```json\n * {\n *   \"keycloak\": {\n *     \"access_token\": \"an authorized Keycloak access token for the user\",\n *     \"id\": \"user's Keycloak ID as a string\",\n *     \"roles\": [\"admin\", \"user\"],\n *     \"groups\": [\"group1\", \"group2\"]\n *   }\n * }\n * ```\n *\n * ## Notes\n * - Parse Server validates the provided `authData` by making a `userinfo` call to Keycloak and ensures the attributes match those returned by Keycloak.\n *\n * ## Keycloak Configuration\n * To configure Keycloak, copy the JSON configuration file generated from Keycloak's setup guide:\n * - [Keycloak Securing Apps Documentation](https://www.keycloak.org/docs/latest/securing_apps/index.html#_javascript_adapter)\n *\n * Place the configuration file on your server, for example:\n * - `auth/keycloak.json`\n *\n * For more information on Keycloak authentication, see:\n * - [Securing Apps Documentation](https://www.keycloak.org/docs/latest/securing_apps/)\n * - [Server Administration Documentation](https://www.keycloak.org/docs/latest/server_admin/)\n */\n\nconst { Parse } = require('parse/node');\nconst jwksClient = require('jwks-rsa');\nconst jwt = require('jsonwebtoken');\nconst authUtils = require('./utils');\n\nconst arraysEqual = (_arr1, _arr2) => {\n  if (!Array.isArray(_arr1) || !Array.isArray(_arr2) || _arr1.length !== _arr2.length) { return false; }\n\n  var arr1 = _arr1.concat().sort();\n  var arr2 = _arr2.concat().sort();\n\n  for (var i = 0; i < arr1.length; i++) {\n    if (arr1[i] !== arr2[i]) { return false; }\n  }\n\n  return true;\n};\n\nconst getKeycloakKeyByKeyId = async (keyId, jwksUri, cacheMaxEntries, cacheMaxAge) => {\n  const client = jwksClient({\n    jwksUri,\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 verifyAccessToken = async (\n  { access_token, id, roles, groups } = {},\n  { config, cacheMaxEntries, cacheMaxAge } = {}\n) => {\n  if (!(access_token && id)) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Missing access token and/or User id');\n  }\n  if (!config || !(config['auth-server-url'] && config['realm'])) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Missing keycloak configuration');\n  }\n  if (!config['client-id']) {\n    throw new Parse.Error(\n      Parse.Error.OBJECT_NOT_FOUND,\n      'Keycloak auth is not configured. Missing client-id.'\n    );\n  }\n\n  const expectedIssuer = `${config['auth-server-url']}/realms/${config['realm']}`;\n  const jwksUri = `${config['auth-server-url']}/realms/${config['realm']}/protocol/openid-connect/certs`;\n\n  const { kid: keyId } = authUtils.getHeaderFromToken(access_token);\n  const ONE_HOUR_IN_MS = 3600000;\n\n  cacheMaxAge = cacheMaxAge || ONE_HOUR_IN_MS;\n  cacheMaxEntries = cacheMaxEntries || 5;\n\n  const keycloakKey = await getKeycloakKeyByKeyId(keyId, jwksUri, cacheMaxEntries, cacheMaxAge);\n  const signingKey = keycloakKey.publicKey || keycloakKey.rsaPublicKey;\n\n  let jwtClaims;\n  try {\n    jwtClaims = jwt.verify(access_token, signingKey, {\n      algorithms: ['RS256'],\n    });\n  } catch (exception) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${exception.message}`);\n  }\n\n  if (jwtClaims.iss !== expectedIssuer) {\n    throw new Parse.Error(\n      Parse.Error.OBJECT_NOT_FOUND,\n      `access token not issued by correct provider - expected: ${expectedIssuer} | from: ${jwtClaims.iss}`\n    );\n  }\n\n  if (jwtClaims.azp !== config['client-id']) {\n    throw new Parse.Error(\n      Parse.Error.OBJECT_NOT_FOUND,\n      `access token is not authorized for this client - expected: ${config['client-id']} | from: ${jwtClaims.azp}`\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  const rolesMatch = jwtClaims.roles === roles || arraysEqual(jwtClaims.roles, roles);\n  const groupsMatch = jwtClaims.groups === groups || arraysEqual(jwtClaims.groups, groups);\n\n  if (!rolesMatch || !groupsMatch) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid authentication');\n  }\n\n  return jwtClaims;\n};\n\nfunction validateAuthData(authData, options = {}) {\n  return verifyAccessToken(authData, options);\n}\n\nfunction validateAppId() {\n  return Promise.resolve();\n}\n\nmodule.exports = {\n  validateAppId,\n  validateAuthData,\n};\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/ldap.js

@@ -0,0 +1,193 @@
+"use strict";
+
+/**
+ * Parse Server authentication adapter for LDAP.
+ *
+ * @class LDAP
+ * @param {Object} options - The adapter configuration options.
+ * @param {String} options.url - The LDAP server URL. Must start with `ldap://` or `ldaps://`.
+ * @param {String} options.suffix - The LDAP suffix for user distinguished names (DN).
+ * @param {String} [options.dn] - The distinguished name (DN) template for user authentication. Replace `{{id}}` with the username.
+ * @param {Object} [options.tlsOptions] - Options for LDAPS TLS connections.
+ * @param {String} [options.groupCn] - The common name (CN) of the group to verify user membership.
+ * @param {String} [options.groupFilter] - The LDAP search filter for groups, with `{{id}}` replaced by the username.
+ *
+ * @param {Object} authData - The authentication data provided by the client.
+ * @param {String} authData.id - The user's LDAP username.
+ * @param {String} authData.password - The user's LDAP password.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for LDAP authentication, use the following structure:
+ * ```javascript
+ * {
+ *   auth: {
+ *     ldap: {
+ *       url: 'ldaps://ldap.example.com',
+ *       suffix: 'ou=users,dc=example,dc=com',
+ *       groupCn: 'admins',
+ *       groupFilter: '(memberUid={{id}})',
+ *       tlsOptions: {
+ *         rejectUnauthorized: false
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ## Authentication Process
+ * 1. Validates the provided `authData` using an LDAP bind operation.
+ * 2. Optionally, verifies that the user belongs to a specific group by performing an LDAP search using the provided `groupCn` or `groupFilter`.
+ *
+ * ## Auth Payload
+ * The adapter requires the following `authData` fields:
+ * - `id`: The user's LDAP username.
+ * - `password`: The user's LDAP password.
+ *
+ * ### Example Auth Payload
+ * ```json
+ * {
+ *   "ldap": {
+ *     "id": "jdoe",
+ *     "password": "password123"
+ *   }
+ * }
+ * ```
+ *
+ * @example <caption>Configuration Example</caption>
+ * // Example Parse Server configuration:
+ * const config = {
+ *   auth: {
+ *     ldap: {
+ *       url: 'ldaps://ldap.example.com',
+ *       suffix: 'ou=users,dc=example,dc=com',
+ *       groupCn: 'admins',
+ *       groupFilter: '(memberUid={{id}})',
+ *       tlsOptions: {
+ *         rejectUnauthorized: false
+ *       }
+ *     }
+ *   }
+ * };
+ *
+ * @see {@link https://ldap.com/ LDAP Basics}
+ * @see {@link https://ldap.com/ldap-filters/ LDAP Filters}
+ */
+
+const ldapjs = require('ldapjs');
+const Parse = require('parse/node').Parse;
+
+// Escape LDAP DN special characters per RFC 4514
+// https://datatracker.ietf.org/doc/html/rfc4514#section-2.4
+function escapeDN(value) {
+  let escaped = value.replace(/\\/g, '\\\\').replace(/,/g, '\\,').replace(/=/g, '\\=').replace(/\+/g, '\\+').replace(/</g, '\\<').replace(/>/g, '\\>').replace(/#/g, '\\#').replace(/;/g, '\\;').replace(/"/g, '\\"');
+  if (escaped.startsWith(' ')) {
+    escaped = '\\ ' + escaped.slice(1);
+  }
+  if (escaped.endsWith(' ')) {
+    escaped = escaped.slice(0, -1) + '\\ ';
+  }
+  return escaped;
+}
+
+// Escape LDAP filter special characters per RFC 4515
+// https://datatracker.ietf.org/doc/html/rfc4515#section-3
+function escapeFilter(value) {
+  // eslint-disable-next-line no-control-regex
+  return value.replace(/[\\*()\x00]/g, ch => '\\' + ch.charCodeAt(0).toString(16).padStart(2, '0'));
+}
+function validateAuthData(authData, options) {
+  if (!optionsAreValid(options)) {
+    return new Promise((_, reject) => {
+      reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP auth configuration missing'));
+    });
+  }
+  const clientOptions = options.url.startsWith('ldaps://') ? {
+    url: options.url,
+    tlsOptions: options.tlsOptions
+  } : {
+    url: options.url
+  };
+  if (typeof authData.id !== 'string') {
+    return Promise.reject(new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LDAP: Wrong username or password'));
+  }
+  const client = ldapjs.createClient(clientOptions);
+  const escapedId = escapeDN(authData.id);
+  const userCn = typeof options.dn === 'string' ? options.dn.replace('{{id}}', escapedId) : `uid=${escapedId},${options.suffix}`;
+  return new Promise((resolve, reject) => {
+    client.bind(userCn, authData.password, ldapError => {
+      delete authData.password;
+      if (ldapError) {
+        let error;
+        switch (ldapError.code) {
+          case 49:
+            error = new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LDAP: Wrong username or password');
+            break;
+          case 'DEPTH_ZERO_SELF_SIGNED_CERT':
+            error = new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LDAPS: Certificate mismatch');
+            break;
+          default:
+            error = new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LDAP: Somthing went wrong (' + ldapError.code + ')');
+        }
+        reject(error);
+        client.destroy(ldapError);
+        return;
+      }
+      if (typeof options.groupCn === 'string' && typeof options.groupFilter === 'string') {
+        searchForGroup(client, options, authData.id, resolve, reject);
+      } else {
+        client.unbind();
+        client.destroy();
+        resolve();
+      }
+    });
+  });
+}
+function optionsAreValid(options) {
+  return typeof options === 'object' && typeof options.suffix === 'string' && typeof options.url === 'string' && (options.url.startsWith('ldap://') || options.url.startsWith('ldaps://') && typeof options.tlsOptions === 'object');
+}
+function searchForGroup(client, options, id, resolve, reject) {
+  const filter = options.groupFilter.replace(/{{id}}/gi, escapeFilter(id));
+  const opts = {
+    scope: 'sub',
+    filter: filter
+  };
+  let found = false;
+  client.search(options.suffix, opts, (searchError, res) => {
+    if (searchError) {
+      client.unbind();
+      client.destroy();
+      return reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP group search failed'));
+    }
+    res.on('searchEntry', entry => {
+      if (entry.pojo.attributes.find(obj => obj.type === 'cn').values.includes(options.groupCn)) {
+        found = true;
+        client.unbind();
+        client.destroy();
+        return resolve();
+      }
+    });
+    res.on('end', () => {
+      if (!found) {
+        client.unbind();
+        client.destroy();
+        return reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP: User not in group'));
+      }
+    });
+    res.on('error', () => {
+      client.unbind();
+      client.destroy();
+      return reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP group search failed'));
+    });
+  });
+}
+function validateAppId() {
+  return Promise.resolve();
+}
+module.exports = {
+  validateAppId,
+  validateAuthData,
+  escapeDN,
+  escapeFilter
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ldapjs","require","Parse","escapeDN","value","escaped","replace","startsWith","slice","endsWith","escapeFilter","ch","charCodeAt","toString","padStart","validateAuthData","authData","options","optionsAreValid","Promise","_","reject","Error","INTERNAL_SERVER_ERROR","clientOptions","url","tlsOptions","id","OBJECT_NOT_FOUND","client","createClient","escapedId","userCn","dn","suffix","resolve","bind","password","ldapError","error","code","destroy","groupCn","groupFilter","searchForGroup","unbind","filter","opts","scope","found","search","searchError","res","on","entry","pojo","attributes","find","obj","type","values","includes","validateAppId","module","exports"],"sources":["../../../src/Adapters/Auth/ldap.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for LDAP.\n *\n * @class LDAP\n * @param {Object} options - The adapter configuration options.\n * @param {String} options.url - The LDAP server URL. Must start with `ldap://` or `ldaps://`.\n * @param {String} options.suffix - The LDAP suffix for user distinguished names (DN).\n * @param {String} [options.dn] - The distinguished name (DN) template for user authentication. Replace `{{id}}` with the username.\n * @param {Object} [options.tlsOptions] - Options for LDAPS TLS connections.\n * @param {String} [options.groupCn] - The common name (CN) of the group to verify user membership.\n * @param {String} [options.groupFilter] - The LDAP search filter for groups, with `{{id}}` replaced by the username.\n *\n * @param {Object} authData - The authentication data provided by the client.\n * @param {String} authData.id - The user's LDAP username.\n * @param {String} authData.password - The user's LDAP password.\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for LDAP authentication, use the following structure:\n * ```javascript\n * {\n *   auth: {\n *     ldap: {\n *       url: 'ldaps://ldap.example.com',\n *       suffix: 'ou=users,dc=example,dc=com',\n *       groupCn: 'admins',\n *       groupFilter: '(memberUid={{id}})',\n *       tlsOptions: {\n *         rejectUnauthorized: false\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * ## Authentication Process\n * 1. Validates the provided `authData` using an LDAP bind operation.\n * 2. Optionally, verifies that the user belongs to a specific group by performing an LDAP search using the provided `groupCn` or `groupFilter`.\n *\n * ## Auth Payload\n * The adapter requires the following `authData` fields:\n * - `id`: The user's LDAP username.\n * - `password`: The user's LDAP password.\n *\n * ### Example Auth Payload\n * ```json\n * {\n *   \"ldap\": {\n *     \"id\": \"jdoe\",\n *     \"password\": \"password123\"\n *   }\n * }\n * ```\n *\n * @example <caption>Configuration Example</caption>\n * // Example Parse Server configuration:\n * const config = {\n *   auth: {\n *     ldap: {\n *       url: 'ldaps://ldap.example.com',\n *       suffix: 'ou=users,dc=example,dc=com',\n *       groupCn: 'admins',\n *       groupFilter: '(memberUid={{id}})',\n *       tlsOptions: {\n *         rejectUnauthorized: false\n *       }\n *     }\n *   }\n * };\n *\n * @see {@link https://ldap.com/ LDAP Basics}\n * @see {@link https://ldap.com/ldap-filters/ LDAP Filters}\n */\n\n\nconst ldapjs = require('ldapjs');\nconst Parse = require('parse/node').Parse;\n\n// Escape LDAP DN special characters per RFC 4514\n// https://datatracker.ietf.org/doc/html/rfc4514#section-2.4\nfunction escapeDN(value) {\n  let escaped = value\n    .replace(/\\\\/g, '\\\\\\\\')\n    .replace(/,/g, '\\\\,')\n    .replace(/=/g, '\\\\=')\n    .replace(/\\+/g, '\\\\+')\n    .replace(/</g, '\\\\<')\n    .replace(/>/g, '\\\\>')\n    .replace(/#/g, '\\\\#')\n    .replace(/;/g, '\\\\;')\n    .replace(/\"/g, '\\\\\"');\n  if (escaped.startsWith(' ')) {\n    escaped = '\\\\ ' + escaped.slice(1);\n  }\n  if (escaped.endsWith(' ')) {\n    escaped = escaped.slice(0, -1) + '\\\\ ';\n  }\n  return escaped;\n}\n\n// Escape LDAP filter special characters per RFC 4515\n// https://datatracker.ietf.org/doc/html/rfc4515#section-3\nfunction escapeFilter(value) {\n  // eslint-disable-next-line no-control-regex\n  return value.replace(/[\\\\*()\\x00]/g, ch =>\n    '\\\\' + ch.charCodeAt(0).toString(16).padStart(2, '0')\n  );\n}\n\nfunction validateAuthData(authData, options) {\n  if (!optionsAreValid(options)) {\n    return new Promise((_, reject) => {\n      reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP auth configuration missing'));\n    });\n  }\n  const clientOptions = options.url.startsWith('ldaps://')\n    ? { url: options.url, tlsOptions: options.tlsOptions }\n    : { url: options.url };\n\n  if (typeof authData.id !== 'string') {\n    return Promise.reject(\n      new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LDAP: Wrong username or password')\n    );\n  }\n  const client = ldapjs.createClient(clientOptions);\n  const escapedId = escapeDN(authData.id);\n  const userCn =\n    typeof options.dn === 'string'\n      ? options.dn.replace('{{id}}', escapedId)\n      : `uid=${escapedId},${options.suffix}`;\n\n  return new Promise((resolve, reject) => {\n    client.bind(userCn, authData.password, ldapError => {\n      delete authData.password;\n      if (ldapError) {\n        let error;\n        switch (ldapError.code) {\n          case 49:\n            error = new Parse.Error(\n              Parse.Error.OBJECT_NOT_FOUND,\n              'LDAP: Wrong username or password'\n            );\n            break;\n          case 'DEPTH_ZERO_SELF_SIGNED_CERT':\n            error = new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LDAPS: Certificate mismatch');\n            break;\n          default:\n            error = new Parse.Error(\n              Parse.Error.OBJECT_NOT_FOUND,\n              'LDAP: Somthing went wrong (' + ldapError.code + ')'\n            );\n        }\n        reject(error);\n        client.destroy(ldapError);\n        return;\n      }\n\n      if (typeof options.groupCn === 'string' && typeof options.groupFilter === 'string') {\n        searchForGroup(client, options, authData.id, resolve, reject);\n      } else {\n        client.unbind();\n        client.destroy();\n        resolve();\n      }\n    });\n  });\n}\n\nfunction optionsAreValid(options) {\n  return (\n    typeof options === 'object' &&\n    typeof options.suffix === 'string' &&\n    typeof options.url === 'string' &&\n    (options.url.startsWith('ldap://') ||\n      (options.url.startsWith('ldaps://') && typeof options.tlsOptions === 'object'))\n  );\n}\n\nfunction searchForGroup(client, options, id, resolve, reject) {\n  const filter = options.groupFilter.replace(/{{id}}/gi, escapeFilter(id));\n  const opts = {\n    scope: 'sub',\n    filter: filter,\n  };\n  let found = false;\n  client.search(options.suffix, opts, (searchError, res) => {\n    if (searchError) {\n      client.unbind();\n      client.destroy();\n      return reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP group search failed'));\n    }\n    res.on('searchEntry', entry => {\n      if (entry.pojo.attributes.find(obj => obj.type === 'cn').values.includes(options.groupCn)) {\n        found = true;\n        client.unbind();\n        client.destroy();\n        return resolve();\n      }\n    });\n    res.on('end', () => {\n      if (!found) {\n        client.unbind();\n        client.destroy();\n        return reject(\n          new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP: User not in group')\n        );\n      }\n    });\n    res.on('error', () => {\n      client.unbind();\n      client.destroy();\n      return reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP group search failed'));\n    });\n  });\n}\n\nfunction validateAppId() {\n  return Promise.resolve();\n}\n\nmodule.exports = {\n  validateAppId,\n  validateAuthData,\n  escapeDN,\n  escapeFilter,\n};\n"],"mappings":"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","ignoreList":[]}