Beast Attack in Strapi with Api Keys

A Beast Attack (Bypassing Security via Abused Trust) against Strapi when API keys are used occurs because the API key is treated as a strong identity proof, while the authorization layer may still rely on object-level permissions that are not re-validated per request. Strapi’s role-based access control (RBAC) assigns permissions to roles, and API keys map to a service identity that can be assigned elevated scopes. When endpoints expose references to other resources (for example, a /uploads endpoint returning a strapi_id tied to a user or a content type), an attacker who steals or enumerates an API key can leverage it to traverse those references and access data that the key’s role should not permit.

Consider an authenticated request using an API key with a scoped permission to read articles but not users. If the article schema contains a relation to a user (author), and the API response leaks a user id or the endpoint allows filtering by that relation, an attacker can submit crafted parameters such as filters or populate fields to reach user data. This is a BOLA/IDOR pattern enabled by trusting the API key alone. The API key proves possession but does not enforce row-level boundaries; Strapi’s runtime authorization must still evaluate whether the requesting identity is allowed to access the specific instance. If those checks are missing or misconfigured, the Beast Attack succeeds.

Additionally, if Strapi’s API key is exposed in client-side code, logs, or browser history, and the API exposes open endpoints (e.g., public uploads or GraphQL queries) that accept user-controlled input like IDs or slugs, an attacker can chain the static key with parameterized inputs to probe for references across content types. The risk is amplified when the OpenAPI spec exposes relations without clarifying that runtime authorization must re-check ownership on every lookup. middleBrick scanning this surface will flag findings such as missing property authorization and BOLA/IDOR under the 12 parallel checks, highlighting that the API key does not implicitly equate to instance-level clearance.

Remediation focuses on ensuring each request re-validates permissions against the specific resource instance, even when an API key is present. Do not rely solely on role-level permissions; enforce ownership checks in controllers and policies. For example, in a custom controller, resolve the resource and confirm the requesting identity (derived from the API key mapping) matches the resource’s user identifier before returning data.

// plugins/users/controllers/api-key-auth.js
'use strict';

module.exports = {
  async findMe(ctx) {
    const { user } = ctx.state; // injected by Strapi identity resolver linked to API key
    const { id } = ctx.params;

    if (String(user.id) !== String(id)) {
      return ctx.unauthorized('Access denied: mismatched instance ownership');
    }

    const entry = await strapi.entityService.findOne('api::profile.profile', id, {
      populate: { avatar: true },
    });
    return entry;
  },
};

In policies, enforce checks for relations and populate paths. If an API key scopes a role to articles, ensure that any populate or filter on user relations is constrained to the authenticated identity derived from the key.

// api/article/config/policies.js
'use strict';

module.exports = {
  async restrictArticleAccess(ctx, next) {
    const { user } = ctx.state;
    const { author } = ctx.request.query;

    // Ensure the article’s author matches the identity bound to the API key
    if (author && String(author) !== String(user.id)) {
      return ctx.forbidden('You cannot query articles for this author');
    }

    await next();
  },
};

Rotate API keys regularly via Strapi admin and avoid embedding them in frontend bundles or logs. Use environment variables and restrict key scopes to the minimum required permissions. middleBrick’s CLI can be run as part of verification: middlebrick scan <url>, and the Pro plan’s GitHub Action can gate merges if new endpoints introduce missing property authorization. The MCP Server allows AI coding assistants to trigger scans directly from the IDE when adjusting schemas or policies.