/

CVE-2026-33152

Severity:

CRITICAL RISK

(9.1)

Missing Authentication Rate Limiting / Brute-Force

CVE-2026-33152

Analyzed

Vulnerability type

Category:

Missing Authentication Rate Limiting / Brute-Force Protection

CWE:

CWE-307

Impact:

Account Compromise via Credential Brute Forcing

Severity:

CRITICAL RISK

(9.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Tandoor Recipes versions prior to 2.6.0 expose a weakness in their API authentication flow by enabling HTTP Basic Authentication without any rate limiting or account lockout controls.

While the HTML login form is protected by AllAuth rate limiting, API endpoints that accept Basic Authorization headers can be brute-forced indefinitely, allowing high-speed password guessing against known usernames.

Affected context

This vulnerability affects deployments of Tandoor Recipes that:

  • Use Django REST Framework with BasicAuthentication enabled as a default authentication backend
  • Expose API endpoints that accept authenticated requests (e.g., user-specific recipe, planning, or shopping list APIs)
  • Rely on AllAuth's ACCOUNT_RATE_LIMITS for protection, assuming it covers all login vectors

In these conditions, the HTML login endpoint at /accounts/login/ is protected, but API endpoints using Authorization: Basic headers are not subject to the same rate limiting or account lockout policies.

Exploit preconditions

  • Attack surface: Any exposed API endpoint in Tandoor Recipes that requires authenticated access and accepts HTTP Basic Authentication.
  • Required access: Network reachability to the Tandoor Recipes instance (e.g., internet-facing or accessible from an internal network).
  • Attacker knowledge: At least one valid or plausible username or email address in the system.
  • Trigger point: Repeated HTTP requests to authenticated API endpoints using crafted Authorization: Basic headers containing guessed credentials.
  • Why exploitation is possible: Rate limiting and lockout protections are only applied to the web form login endpoint. BasicAuthentication for API requests bypasses these protections, accepting unlimited authentication attempts without increasing delay or locking accounts.

Why this happens

The core issue stems from an inconsistent application of authentication hardening controls across different login channels.

Tandoor Recipes configures Django REST Framework with BasicAuthentication as a default backend while relying on AllAuth's ACCOUNT_RATE_LIMITS to protect login attempts. However, the AllAuth configuration is scoped to the HTML-based login endpoint (/accounts/login/) and does not apply to API calls using Authorization: Basic headers.

This design creates a blind spot where one authentication vector (form-based login) is rate limited and another vector (API BasicAuth) is not. Conceptually, this maps to CWE-307: Improper Restriction of Excessive Authentication Attempts, where the system fails to bound repeated authentication attempts, enabling brute-force guessing.

Potential impact

  • Attackers could perform high-speed online password guessing against known or guessed usernames.
  • User accounts could be compromised if passwords are weak, reused, or already known from external breaches.
  • Compromised accounts could lead to exposure of private recipe data, meal plans, and personal information tied to the application.
  • If administrative or highly privileged accounts are compromised, attackers could tamper with configuration, user management, or application data at scale.
  • Successful account takeover could be used as a foothold for additional attacks against integrated services (e.g., email, SSO providers, or other connected systems).

General mitigation guidance

Effective mitigation focuses on ensuring consistent authentication protections across all entry points, rather than relying solely on a single login form:

  • Apply rate limiting and/or incremental backoff uniformly to all authentication mechanisms (HTML forms, API endpoints, and programmatic logins).
  • Introduce centralized brute-force protection that operates at the authentication decision layer, independent of the specific endpoint or protocol.
  • Prefer token-based or session-based authentication for APIs, where possible, and guard token issuance with strong anti-automation measures.
  • Enforce account lockout or temporary suspension after a defined number of failed attempts, with careful tuning to avoid easy denial-of-service on legitimate users.
  • Encourage or enforce strong password policies and consider optional multi-factor authentication for high-value accounts.
  • Restrict unnecessary authentication backends; if BasicAuthentication is not required, disable it or scope it narrowly to trusted contexts.

How teams detect issues like this

Organizations can detect and monitor this class of vulnerability and exploitation attempts using a combination of review and runtime analysis:

  • Static and configuration review:
  • Inspect Django REST Framework settings for enabled authentication backends and verify that BasicAuthentication is truly necessary.
  • Check that rate limiting and lockout logic is applied in the authentication flow itself, not solely at the web form layer.
  • Use static analysis or configuration linting to flag authentication mechanisms that bypass centralized rate limiting.
  • Code review signals:
  • Look for multiple authentication entry points (HTML forms, API endpoints, mobile clients) and validate that each is covered by anti-brute-force controls.
  • Identify use of BasicAuthentication or similar mechanisms without clear references to throttling or attempt counters.
  • Runtime and log-based monitoring:
  • Analyze access logs for repetitive failed Authorization: Basic attempts, particularly from the same IP range or targeting the same usernames.
  • Configure security monitoring to alert on abnormal spikes in authentication failures to API endpoints.
  • Automated tooling:
  • Incorporate API security scanners or dynamic analysis tools that simulate brute-force conditions and verify the presence of rate limiting.

Sources

SourceLink
github.comgithub.com/TandoorRecipes/recipes/releases/tag/2.6.0
github.comgithub.com/TandoorRecipes/recipes/security/advisories/GHSA-7m7c-jjqc-r522

Frequently asked

questions

Yes. If a Tandoor Recipes instance is reachable over the network and exposes API endpoints with BasicAuthentication enabled, an attacker can exploit this issue remotely by sending repeated authenticated requests with guessed credentials.

The attacker does not need valid credentials to begin exploitation, but they typically need at least one known or guessable username or email. From there, they can attempt unlimited password guesses via the API until one succeeds.

The safest approach is to centralize and enforce rate limiting and lockout logic across all authentication paths, ensuring that any credential-based login attempt—whether via HTML form or API—is subject to the same brute-force protections. Removing or strictly scoping BasicAuthentication and favoring more robust, token-based methods can further reduce risk.

When designing authentication, treat it as a single logical service rather than per-endpoint functionality. Define organization-wide requirements for rate limiting, lockout, and monitoring, and ensure all authentication mechanisms (web, API, mobile) consume the same hardened implementation. Regular security reviews and automated checks of authentication settings can help catch inconsistencies before release.

Find out what's already
exploitable in your codebase.