@strapi/plugin-users-permissions 0.0.0-experimental.62ebf57bb35846666febb5ee2078fe02fe990f57 → 0.0.0-experimental.6340da17068c3bed7fb006e7bcc554c71129e282

package/server/controllers/role.js

@@ -1,10 +1,19 @@
 'use strict';
 
 const _ = require('lodash');
-const { ApplicationError, ValidationError } = require('@strapi/utils').errors;
+const { async, errors } = require('@strapi/utils');
 const { getService } = require('../utils');
 const { validateDeleteRoleBody } = require('./validation/user');
 
+const { ApplicationError, ValidationError } = errors;
+
+const sanitizeOutput = async (role) => {
+  const { sanitizeLocalizationFields } = strapi.plugin('i18n').service('sanitize');
+  const schema = strapi.getModel('plugin::users-permissions.role');
+
+  return async.pipe(sanitizeLocalizationFields(schema))(role);
+};
+
 module.exports = {
   /**
    * Default action.
@@ -30,13 +39,17 @@ module.exports = {
       return ctx.notFound();
     }
 
-    ctx.send({ role });
+    const safeRole = await sanitizeOutput(role);
+
+    ctx.send({ role: safeRole });
   },
 
   async find(ctx) {
     const roles = await getService('role').find();
 
-    ctx.send({ roles });
+    const safeRoles = await Promise.all(roles.map(sanitizeOutput));
+
+    ctx.send({ roles: safeRoles });
   },
 
   async updateRole(ctx) {
@@ -59,7 +72,7 @@ module.exports = {
     }
 
     // Fetch public role.
-    const publicRole = await strapi
+    const publicRole = await strapi.db
       .query('plugin::users-permissions.role')
       .findOne({ where: { type: 'public' } });
 

package/server/controllers/user.js

@@ -11,28 +11,27 @@ const utils = require('@strapi/utils');
 const { getService } = require('../utils');
 const { validateCreateUserBody, validateUpdateUserBody } = require('./validation/user');
 
-const { sanitize, validate } = utils;
 const { ApplicationError, ValidationError, NotFoundError } = utils.errors;
 
 const sanitizeOutput = async (user, ctx) => {
   const schema = strapi.getModel('plugin::users-permissions.user');
   const { auth } = ctx.state;
 
-  return sanitize.contentAPI.output(user, schema, { auth });
+  return strapi.contentAPI.sanitize.output(user, schema, { auth });
 };
 
 const validateQuery = async (query, ctx) => {
   const schema = strapi.getModel('plugin::users-permissions.user');
   const { auth } = ctx.state;
 
-  return validate.contentAPI.query(query, schema, { auth });
+  return strapi.contentAPI.validate.query(query, schema, { auth });
 };
 
 const sanitizeQuery = async (query, ctx) => {
   const schema = strapi.getModel('plugin::users-permissions.user');
   const { auth } = ctx.state;
 
-  return sanitize.contentAPI.query(query, schema, { auth });
+  return strapi.contentAPI.sanitize.query(query, schema, { auth });
 };
 
 module.exports = {
@@ -49,7 +48,7 @@ module.exports = {
 
     const { email, username, role } = ctx.request.body;
 
-    const userWithSameUsername = await strapi
+    const userWithSameUsername = await strapi.db
       .query('plugin::users-permissions.user')
       .findOne({ where: { username } });
 
@@ -58,7 +57,7 @@ module.exports = {
     }
 
     if (advanced.unique_email) {
-      const userWithSameEmail = await strapi
+      const userWithSameEmail = await strapi.db
         .query('plugin::users-permissions.user')
         .findOne({ where: { email: email.toLowerCase() } });
 
@@ -74,7 +73,7 @@ module.exports = {
     };
 
     if (!role) {
-      const defaultRole = await strapi
+      const defaultRole = await strapi.db
         .query('plugin::users-permissions.role')
         .findOne({ where: { type: advanced.default_role } });
 
@@ -115,7 +114,7 @@ module.exports = {
     }
 
     if (_.has(ctx.request.body, 'username')) {
-      const userWithSameUsername = await strapi
+      const userWithSameUsername = await strapi.db
         .query('plugin::users-permissions.user')
         .findOne({ where: { username } });
 
@@ -125,7 +124,7 @@ module.exports = {
     }
 
     if (_.has(ctx.request.body, 'email') && advancedConfigs.unique_email) {
-      const userWithSameEmail = await strapi
+      const userWithSameEmail = await strapi.db
         .query('plugin::users-permissions.user')
         .findOne({ where: { email: email.toLowerCase() } });
 

package/server/controllers/validation/auth.js

@@ -7,11 +7,35 @@ const callbackSchema = yup.object({
   password: yup.string().required(),
 });
 
-const registerSchema = yup.object({
-  email: yup.string().email().required(),
-  username: yup.string().required(),
-  password: yup.string().required(),
-});
+const createRegisterSchema = (config) =>
+  yup.object({
+    email: yup.string().email().required(),
+    username: yup.string().required(),
+    password: yup
+      .string()
+      .required()
+      .test(function (value) {
+        if (!value) return true;
+        const isValid = new TextEncoder().encode(value).length <= 72;
+        if (!isValid) {
+          return this.createError({ message: 'Password must be less than 73 bytes' });
+        }
+        return true;
+      })
+      .test(async function (value) {
+        if (typeof config?.validatePassword === 'function') {
+          try {
+            const isValid = await config.validatePassword(value);
+            if (!isValid) {
+              return this.createError({ message: 'Password validation failed.' });
+            }
+          } catch (error) {
+            return this.createError({ message: error.message || 'An error occurred.' });
+          }
+        }
+        return true;
+      }),
+  });
 
 const sendEmailConfirmationSchema = yup.object({
   email: yup.string().email().required(),
@@ -27,31 +51,86 @@ const forgotPasswordSchema = yup
   })
   .noUnknown();
 
-const resetPasswordSchema = yup
-  .object({
-    password: yup.string().required(),
-    passwordConfirmation: yup.string().required(),
-    code: yup.string().required(),
-  })
-  .noUnknown();
+const createResetPasswordSchema = (config) =>
+  yup
+    .object({
+      password: yup
+        .string()
+        .required()
+        .test(function (value) {
+          if (!value) return true;
+          const isValid = new TextEncoder().encode(value).length <= 72;
+          if (!isValid) {
+            return this.createError({ message: 'Password must be less than 73 bytes' });
+          }
+          return true;
+        })
+        .test(async function (value) {
+          if (typeof config?.validatePassword === 'function') {
+            try {
+              const isValid = await config.validatePassword(value);
+              if (!isValid) {
+                return this.createError({ message: 'Password validation failed.' });
+              }
+            } catch (error) {
+              return this.createError({ message: error.message || 'An error occurred.' });
+            }
+          }
+          return true;
+        }),
+      passwordConfirmation: yup
+        .string()
+        .required()
+        .oneOf([yup.ref('password')], 'Passwords do not match'),
 
-const changePasswordSchema = yup
-  .object({
-    password: yup.string().required(),
-    passwordConfirmation: yup
-      .string()
-      .required()
-      .oneOf([yup.ref('password')], 'Passwords do not match'),
-    currentPassword: yup.string().required(),
-  })
-  .noUnknown();
+      code: yup.string().required(),
+    })
+    .noUnknown();
+
+const createChangePasswordSchema = (config) =>
+  yup
+    .object({
+      password: yup
+        .string()
+        .required()
+        .test(function (value) {
+          if (!value) return true;
+          const isValid = new TextEncoder().encode(value).length <= 72;
+          if (!isValid) {
+            return this.createError({ message: 'Password must be less than 73 bytes' });
+          }
+          return true;
+        })
+        .test(async function (value) {
+          if (typeof config?.validatePassword === 'function') {
+            try {
+              const isValid = await config.validatePassword(value);
+              if (!isValid) {
+                return this.createError({ message: 'Password validation failed.' });
+              }
+            } catch (error) {
+              return this.createError({ message: error.message || 'An error occurred.' });
+            }
+          }
+          return true;
+        }),
+      passwordConfirmation: yup
+        .string()
+        .required()
+        .oneOf([yup.ref('password')], 'Passwords do not match'),
+      currentPassword: yup.string().required(),
+    })
+    .noUnknown();
 
 module.exports = {
   validateCallbackBody: validateYupSchema(callbackSchema),
-  validateRegisterBody: validateYupSchema(registerSchema),
+  validateRegisterBody: (payload, config) =>
+    validateYupSchema(createRegisterSchema(config))(payload),
   validateSendEmailConfirmationBody: validateYupSchema(sendEmailConfirmationSchema),
   validateEmailConfirmationBody: validateYupSchema(validateEmailConfirmationSchema),
   validateForgotPasswordBody: validateYupSchema(forgotPasswordSchema),
-  validateResetPasswordBody: validateYupSchema(resetPasswordSchema),
-  validateChangePasswordBody: validateYupSchema(changePasswordSchema),
+  validateResetPasswordBody: (payload, config) =>
+    validateYupSchema(createResetPasswordSchema(config))(payload),
+  validateChangePasswordBody: (payload, config) =>
+    validateYupSchema(createChangePasswordSchema(config))(payload),
 };

package/server/controllers/validation/user.js

@@ -6,6 +6,17 @@ const deleteRoleSchema = yup.object().shape({
   role: yup.strapiID().required(),
 });
 
+// A role relation entry may be referenced by numeric `id` (legacy) or by
+// `documentId` (the v5 default), but must carry at least one of them.
+const roleRelationEntrySchema = yup
+  .object()
+  .shape({ id: yup.strapiID(), documentId: yup.strapiID() })
+  .test(
+    'id-or-documentId',
+    'Relation entry must include an id or documentId',
+    (entry) => !!entry && (entry.id != null || entry.documentId != null)
+  );
+
 const createUserBodySchema = yup.object().shape({
   email: yup.string().email().required(),
   username: yup.string().min(1).required(),
@@ -17,7 +28,7 @@ const createUserBodySchema = yup.object().shape({
           .shape({
             connect: yup
               .array()
-              .of(yup.object().shape({ id: yup.strapiID().required() }))
+              .of(roleRelationEntrySchema)
               .min(1, 'Users must have a role')
               .required(),
           })
@@ -29,24 +40,37 @@ const createUserBodySchema = yup.object().shape({
 const updateUserBodySchema = yup.object().shape({
   email: yup.string().email().min(1),
   username: yup.string().min(1),
-  password: yup.string().min(1),
+  password: yup
+    .mixed()
+    .test(
+      'password-validation',
+      'Password must be at least 1 character',
+      function validatePassword(value) {
+        if (value == null || value === '') {
+          return true;
+        }
+        return typeof value === 'string' && value.length >= 1;
+      }
+    ),
   role: yup.lazy((value) =>
     typeof value === 'object'
       ? yup.object().shape({
-          connect: yup
-            .array()
-            .of(yup.object().shape({ id: yup.strapiID().required() }))
-            .required(),
+          // connect/disconnect are each optional (matching core relation inputs),
+          // but a role must remain: reject disconnecting every role without
+          // connecting a replacement.
+          connect: yup.array().of(roleRelationEntrySchema),
           disconnect: yup
             .array()
-            .test('CheckDisconnect', 'Cannot remove role', function test(disconnectValue) {
-              if (value.connect.length === 0 && disconnectValue.length > 0) {
+            .of(roleRelationEntrySchema)
+            .test('CheckDisconnect', 'Cannot remove role', function test(disconnect) {
+              const connectValue = value.connect || [];
+              const disconnectValue = disconnect || [];
+              if (connectValue.length === 0 && disconnectValue.length > 0) {
                 return false;
               }
 
               return true;
-            })
-            .required(),
+            }),
         })
       : yup.strapiID()
   ),

package/server/graphql/types/index.js

@@ -10,6 +10,7 @@ const typesFactories = [
   require('./create-role-payload'),
   require('./update-role-payload'),
   require('./delete-role-payload'),
+  require('./user-input'),
 ];
 
 /**

package/server/graphql/types/me.js

@@ -6,6 +6,7 @@ module.exports = ({ nexus }) => {
 
     definition(t) {
       t.nonNull.id('id');
+      t.nonNull.id('documentId');
       t.nonNull.string('username');
       t.string('email');
       t.boolean('confirmed');

package/server/graphql/types/user-input.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const usersPermissionsUserUID = 'plugin::users-permissions.user';
+
+module.exports = ({ nexus, strapi }) => {
+  const { getContentTypeInputName } = strapi.plugin('graphql').service('utils').naming;
+
+  const userContentType = strapi.getModel(usersPermissionsUserUID);
+  const userInputName = getContentTypeInputName(userContentType);
+
+  return nexus.extendInputType({
+    type: userInputName,
+
+    definition(t) {
+      // Manually add the private password field back to the data
+      // input type as it is used for CRUD operations on users
+      t.string('password');
+    },
+  });
+};

package/server/middlewares/rateLimit.js

@@ -6,10 +6,95 @@ const { isString, has, toLower } = require('lodash/fp');
 
 const { RateLimitError } = utils.errors;
 
+/**
+ * Routes where the rate-limit key MUST NOT include a user identifier
+ * derived from `ctx.request.body.email`.
+ *
+ * On these routes the request body either has no `email` field
+ * (e.g. /auth/local uses `identifier`, /auth/reset-password uses
+ * `code`, /auth/change-password uses `currentPassword`) or the
+ * field is not part of the route contract. Including the
+ * attacker-controlled `body.email` in the rate-limit key on these
+ * routes lets a caller obtain a fresh key on every request by
+ * varying that field, effectively bypassing per-IP throttling.
+ *
+ * Comparison uses endsWith so the check is stable under any router
+ * mount prefix (e.g. `/api/auth/local`).
+ *
+ * @see https://github.com/strapi/strapi/security/advisories/GHSA-7mqx-wwh4-f9fw
+ *
+ * When adding a new `rateLimit`-protected auth route whose body does not
+ * use `email` as the real identifier, add its path suffix here (or an
+ * equivalent `routeUsesEmailIdentifier` rule) so the key cannot be split
+ * with arbitrary `body.email` values.
+ */
+const ROUTES_WITHOUT_IDENTIFIER = ['/auth/local', '/auth/reset-password', '/auth/change-password'];
+
+const isOAuthCallbackPath = (requestPath) => requestPath.includes('/connect/');
+
+const routeUsesEmailIdentifier = (requestPath) => {
+  if (isOAuthCallbackPath(requestPath)) {
+    return false;
+  }
+
+  return !ROUTES_WITHOUT_IDENTIFIER.some((route) => requestPath.endsWith(route));
+};
+
+/**
+ * Paths suitable for route matching and prefix keys: POSIX-normalized,
+ * lower-cased, trailing slashes removed so `/api/auth/local` and
+ * `/api/auth/local/` share one bucket.
+ */
+const normalizeRequestPathForRateLimit = (requestPath) => {
+  const normalized = path.normalize(requestPath);
+  const lower = toLower(normalized);
+  return lower.replace(/\/+$/, '') || '/';
+};
+
+const getEmailIdentifierForKey = (body) => {
+  if (!body || !isString(body.email) || body.email === '') {
+    return 'unknownIdentifier';
+  }
+
+  return toLower(body.email);
+};
+
+const buildPrefixKey = (ctx) => {
+  let requestPath;
+  if (!isString(ctx.request.path)) {
+    requestPath = 'invalidPath';
+  } else {
+    requestPath = normalizeRequestPathForRateLimit(ctx.request.path);
+    if (requestPath === '.' || requestPath === '..') {
+      requestPath = 'invalidPath';
+    }
+  }
+
+  if (!routeUsesEmailIdentifier(requestPath)) {
+    return `noIdentifier:${requestPath}:${ctx.request.ip}`;
+  }
+
+  const userIdentifier = getEmailIdentifierForKey(ctx.request.body);
+  return `${userIdentifier}:${requestPath}:${ctx.request.ip}`;
+};
+
+const buildRateLimitLoadConfig = (ctx, rateLimitConfig, routeMiddlewareConfig) => {
+  return {
+    interval: { min: 5 },
+    max: 5,
+    ...rateLimitConfig,
+    ...routeMiddlewareConfig,
+    handler() {
+      throw new RateLimitError();
+    },
+    prefixKey: buildPrefixKey(ctx),
+  };
+};
+
 module.exports =
   (config, { strapi }) =>
   async (ctx, next) => {
-    let rateLimitConfig = strapi.config.get('plugin.users-permissions.ratelimit');
+    let rateLimitConfig = strapi.config.get('plugin::users-permissions.ratelimit');
 
     if (!rateLimitConfig) {
       rateLimitConfig = {
@@ -24,24 +109,15 @@ module.exports =
     if (rateLimitConfig.enabled === true) {
       const rateLimit = require('koa2-ratelimit').RateLimit;
 
-      const userIdentifier = toLower(ctx.request.body.email) || 'unknownIdentifier';
-      const requestPath = isString(ctx.request.path)
-        ? toLower(path.normalize(ctx.request.path))
-        : 'invalidPath';
-
-      const loadConfig = {
-        interval: { min: 5 },
-        max: 5,
-        prefixKey: `${userIdentifier}:${requestPath}:${ctx.request.ip}`,
-        handler() {
-          throw new RateLimitError();
-        },
-        ...rateLimitConfig,
-        ...config,
-      };
+      const loadConfig = buildRateLimitLoadConfig(ctx, rateLimitConfig, config);
 
       return rateLimit.middleware(loadConfig)(ctx, next);
     }
 
     return next();
   };
+
+module.exports.buildPrefixKey = buildPrefixKey;
+module.exports.ROUTES_WITHOUT_IDENTIFIER = ROUTES_WITHOUT_IDENTIFIER;
+module.exports.normalizeRequestPathForRateLimit = normalizeRequestPathForRateLimit;
+module.exports.buildRateLimitLoadConfig = buildRateLimitLoadConfig;

package/server/register.js

@@ -7,7 +7,7 @@ const authStrategy = require('./strategies/users-permissions');
 const sanitizers = require('./utils/sanitize/sanitizers');
 
 module.exports = ({ strapi }) => {
-  strapi.container.get('auth').register('content-api', authStrategy);
+  strapi.get('auth').register('content-api', authStrategy);
   strapi.sanitizers.add('content-api.output', sanitizers.defaultSanitizeOutput);
 
   if (strapi.plugin('graphql')) {
@@ -15,7 +15,7 @@ module.exports = ({ strapi }) => {
   }
 
   if (strapi.plugin('documentation')) {
-    const specPath = path.join(__dirname, '../documentation/content-api.yaml');
+    const specPath = path.join(__dirname, '../../documentation/content-api.yaml');
     const spec = fs.readFileSync(specPath, 'utf8');
 
     strapi