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: Basicheaders 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: Basicattempts, 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.

