easyapi-django 1.1.7__tar.gz → 1.2.0__tar.gz

{easyapi_django-1.1.7/easyapi_django.egg-info → easyapi_django-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easyapi-django
-Version: 1.1.7
+Version: 1.2.0
 Summary: Zero-effort MCP server (and REST API) generator from Django models.
 Author-email: Stamatios Stamou Jr <bushier.outsets.0c@icloud.com>
 License-Expression: MIT
@@ -233,6 +233,10 @@ Defaults are demo-friendly. Production deployments should:
 - **Per-resource ownership.** Set `owner_field = 'owner_id'` on resources where rows belong to a single user — restricts every CRUD operation to the row's owner. `POST` always forces `owner_id` to the caller (override with `allow_owner_override = True` for admin paths).
 - **Authenticated cache.** If you turn on `cache = True` for an authenticated resource, set `session_cache = True` or `cache_scope_fields = (...)` — otherwise responses can leak across users. The framework warns at runtime when it detects this combination.
 - **Tune session TTLs.** `SESSION_TTL` (cookies, default 1800s) and `API_SESSION_TTL` (api-key cache, default 300s) both slide on use. Pick numbers that match your security/UX trade-off.
+- **Never ship `DEBUG = True`.** Under `DEBUG`, edge security (scanner blocking, 4xx flood detection), rate limiting, credential-path defense and abuse blocking are all bypassed for dev ergonomics. The framework logs a loud startup warning when the bypass is active. To decouple from `DEBUG` — e.g. a staging box mirroring production — set `MCP = {'SECURITY_BYPASS': False}` to force protections on (or `True` to bypass without `DEBUG`).
+- **Trust your proxies explicitly.** IP-based rate limits and abuse blocking key on the client IP. `X-Forwarded-For` / `X-Real-IP` are only honored when `REMOTE_ADDR` is in `TRUSTED_PROXIES = ['10.0.0.0/8', ...]`; otherwise `REMOTE_ADDR` wins. Leave it unset behind a proxy and every request looks like it comes from the proxy.
+- **Bound the metrics surface.** The `/metrics` endpoint queries any model in the registry by default. Set `METRICS_MODELS = ['app_Model', ...]` to allowlist which models are queryable. References to credential-named columns (in filters, groups, order or calc) are always rejected.
+- **OAuth clients are public by default.** MCP clients (Claude.ai, ChatGPT, ...) authenticate with PKCE — list them under `MCP['OAUTH_CLIENTS']` with no `client_secret`. A client becomes confidential only with an explicit secret; `/register` never hands out a confidential secret (provision those out of band).
 
 ---
 

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/README.md

@@ -189,6 +189,10 @@ Defaults are demo-friendly. Production deployments should:
 - **Per-resource ownership.** Set `owner_field = 'owner_id'` on resources where rows belong to a single user — restricts every CRUD operation to the row's owner. `POST` always forces `owner_id` to the caller (override with `allow_owner_override = True` for admin paths).
 - **Authenticated cache.** If you turn on `cache = True` for an authenticated resource, set `session_cache = True` or `cache_scope_fields = (...)` — otherwise responses can leak across users. The framework warns at runtime when it detects this combination.
 - **Tune session TTLs.** `SESSION_TTL` (cookies, default 1800s) and `API_SESSION_TTL` (api-key cache, default 300s) both slide on use. Pick numbers that match your security/UX trade-off.
+- **Never ship `DEBUG = True`.** Under `DEBUG`, edge security (scanner blocking, 4xx flood detection), rate limiting, credential-path defense and abuse blocking are all bypassed for dev ergonomics. The framework logs a loud startup warning when the bypass is active. To decouple from `DEBUG` — e.g. a staging box mirroring production — set `MCP = {'SECURITY_BYPASS': False}` to force protections on (or `True` to bypass without `DEBUG`).
+- **Trust your proxies explicitly.** IP-based rate limits and abuse blocking key on the client IP. `X-Forwarded-For` / `X-Real-IP` are only honored when `REMOTE_ADDR` is in `TRUSTED_PROXIES = ['10.0.0.0/8', ...]`; otherwise `REMOTE_ADDR` wins. Leave it unset behind a proxy and every request looks like it comes from the proxy.
+- **Bound the metrics surface.** The `/metrics` endpoint queries any model in the registry by default. Set `METRICS_MODELS = ['app_Model', ...]` to allowlist which models are queryable. References to credential-named columns (in filters, groups, order or calc) are always rejected.
+- **OAuth clients are public by default.** MCP clients (Claude.ai, ChatGPT, ...) authenticate with PKCE — list them under `MCP['OAUTH_CLIENTS']` with no `client_secret`. A client becomes confidential only with an explicit secret; `/register` never hands out a confidential secret (provision those out of band).
 
 ---
 

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi/base.py

@@ -39,6 +39,7 @@ from .helpers import (
     search_regex,
 )
 from .schemas import is_pydantic_model, serialize_output, validate_input
+from .sensitive import looks_sensitive
 from .serializer import CustomJSONEncoder
 from .util import validate_session_key
 from .rate_limit import RateLimiter
@@ -57,6 +58,7 @@ from .settings_helper import (
     get_session_ttl,
     get_setting,
     get_token_max_drift_ms,
+    security_bypassed,
 )
 
 COOKIE_ID = get_cookie_id()
@@ -121,6 +123,27 @@ def _warn_csrf_unprotected_at_startup():
 _warn_csrf_unprotected_at_startup()
 
 
+def _warn_if_security_bypassed_at_startup():
+    """Loud boot warning when edge security + rate limiting are relaxed.
+
+    Keyed to ``SECURITY_BYPASS`` (or ``DEBUG`` when unset). A production
+    box mis-deployed with ``DEBUG=True`` silently disabled the security
+    middleware, rate limiting, credential-path defense and abuse blocking
+    all at once — this makes it visible in logs/Sentry.
+    """
+    if security_bypassed():
+        logger.warning(
+            'SECURITY BYPASS ACTIVE — edge security middleware, rate '
+            'limiting, credential-path defense and abuse blocking are '
+            'DISABLED (SECURITY_BYPASS set, or DEBUG=True with '
+            'SECURITY_BYPASS unset). Never run this in production; set '
+            "MCP['SECURITY_BYPASS'] = False to force protections on.",
+        )
+
+
+_warn_if_security_bypassed_at_startup()
+
+
 class BaseResource(CoreResource):
     # ``True`` historically. Override globally via
     # ``MCP = {'DEFAULT_AUTHENTICATED': False}`` (the generator emits
@@ -352,7 +375,12 @@ class BaseResource(CoreResource):
         if candidate:
             domain = urlparse(candidate).netloc.split(':')[0]
             for origin in ALLOWED_ORIGINS:
-                if domain.endswith(origin):
+                # Boundary match — a bare ``endswith`` let ``evilexample.com``
+                # pass an allowlist of ``example.com``. Accept the domain
+                # itself or a subdomain of it. Leading dot in config is
+                # tolerated (``.example.com`` == ``example.com``).
+                origin = origin.lstrip('.')
+                if domain == origin or domain.endswith(f'.{origin}'):
                     return
 
         raise HTTPException(403, 'Not allowed')
@@ -369,11 +397,11 @@ class BaseResource(CoreResource):
             raise HTTPException(403, 'Blocked due to misbehavior')
 
     async def _enforce_rate_limit(self, request):
-        # Local development with ``DEBUG = True`` bypasses rate limiting
-        # and abuse blocking. Hammering ``/docs`` while wiring up auth
-        # would otherwise trigger a 24h block on 127.0.0.1 — annoying
-        # and almost never the right behaviour for a dev box.
-        if getattr(django_settings, 'DEBUG', False):
+        # Local development bypasses rate limiting and abuse blocking.
+        # Hammering ``/docs`` while wiring up auth would otherwise trigger
+        # a 24h block on 127.0.0.1 — annoying and almost never right for a
+        # dev box. Controlled by ``SECURITY_BYPASS`` (falls back to DEBUG).
+        if security_bypassed():
             return
 
         await self.check_is_blocked(self.identifier)
@@ -409,7 +437,7 @@ class BaseResource(CoreResource):
         keys derived from ``self.user`` resolve. Keys returning ``None``
         are skipped (e.g. unauthenticated endpoints that opt-in to a
         per-user bucket as well — only fires when a user is present)."""
-        if not self.rate_limits or getattr(django_settings, 'DEBUG', False):
+        if not self.rate_limits or security_bypassed():
             return
         for spec in self.rate_limits:
             key = spec['key']
@@ -1294,7 +1322,7 @@ class BaseResource(CoreResource):
                 if field in self.list_exclude_fields:
                     continue
 
-                if field == 'password' or field in self.sensitive_fields:
+                if looks_sensitive(field) or field in self.sensitive_fields:
                     result[field] = '*********'
                 else:
                     result[field] = getattr(row, field, None)
@@ -1418,7 +1446,7 @@ class BaseResource(CoreResource):
                 result[key].append(item)
 
         for field in self.edit_fields:
-            if field == 'password' or field in self.sensitive_fields:
+            if looks_sensitive(field) or field in self.sensitive_fields:
                 result[field] = '*********'
             else:
                 result[field] = getattr(self.obj, field, None)

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi/calc.py

@@ -18,6 +18,7 @@ import pytz
 from .dates import Dates
 from .exception import HTTPException
 from .filters import Filter as OrmFilter
+from .sensitive import looks_sensitive
 from .settings_helper import get_metrics_max_execution_ms, get_metrics_models
 from .util import normalize_field
 
@@ -570,6 +571,74 @@ def normalize_groups(
     return values, keys
 
 
+def _collect_condition_fields(node, refs):
+    """Walk a Layer-2 ``conditions`` tree collecting every ``field``."""
+    if isinstance(node, dict):
+        if 'logical_operator' in node:
+            for rule in node.get('rules') or []:
+                _collect_condition_fields(rule, refs)
+        elif node.get('field'):
+            refs.append(node['field'])
+    elif isinstance(node, list):
+        for item in node:
+            _collect_condition_fields(item, refs)
+
+
+def _reject_sensitive_fields(data):
+    """Block any field reference in the metrics body that touches a
+    credential-named column.
+
+    The metrics endpoint references models/fields straight from the
+    request body — filters, groups, order and calc targets. Without this
+    guard, an authenticated caller can turn counts into a boolean oracle
+    (``owner__password__startswith=a`` → read the count) or read values
+    directly (``group_by.fields=['owner__api_key']`` → the api_key comes
+    back as a group label; the LIST/detail sensitive-field scrub does not
+    cover metrics output). We reject any reference whose ``__``-split
+    segments include a sensitive name.
+    """
+    refs = []
+
+    calc_cfg = data.get('calc') or {}
+    on_field = calc_cfg.get('field')
+    if isinstance(on_field, str):
+        refs.append(on_field)
+    elif isinstance(on_field, list):
+        refs += [f for f in on_field if isinstance(f, str)]
+
+    gb = data.get('group_by') or {}
+    refs += [f for f in (gb.get('fields') or []) if isinstance(f, str)]
+    date_group = gb.get('date') or {}
+    if isinstance(date_group.get('field'), str):
+        refs.append(date_group['field'])
+
+    refs += [f for f in (data.get('additional_fields') or []) if isinstance(f, str)]
+    refs += [o.lstrip('-') for o in (data.get('order') or []) if isinstance(o, str)]
+
+    filter_by = data.get('filter_by') or {}
+    for key, value in (filter_by.get('fields') or {}).items():
+        if key == 'or_conditions':
+            for cond in value or []:
+                if isinstance(cond, dict):
+                    refs += list(cond.keys())
+        else:
+            refs.append(key)
+    period = filter_by.get('period') or {}
+    if isinstance(period.get('field'), str):
+        refs.append(period['field'])
+
+    _collect_condition_fields(data.get('conditions'), refs)
+
+    for ref in refs:
+        for segment in str(ref).split('__'):
+            if looks_sensitive(segment):
+                raise HTTPException(
+                    403,
+                    f'Filtering, grouping or ordering on a sensitive '
+                    f'field is not allowed: {ref}',
+                )
+
+
 async def get_results(timezone, data, base_queryset=None):
     """Entry point for the metrics endpoint.
 
@@ -589,6 +658,8 @@ async def get_results(timezone, data, base_queryset=None):
     if allowed_models is not None and model_label not in allowed_models:
         raise HTTPException(403, f'Metrics not allowed for model "{model_label}"')
 
+    _reject_sensitive_fields(data)
+
     model = get_model(model_label)
 
     conditions = data.get('conditions')
@@ -623,8 +694,6 @@ async def get_results(timezone, data, base_queryset=None):
     date_group = groups.get('date', {})
     groups = groups.get('fields', [])
 
-    extra = data.get('extra')
-
     filter_by = data.get('filter_by', {})
     filtered_by_fields = filter_by.get('fields', {})
 
@@ -649,9 +718,6 @@ async def get_results(timezone, data, base_queryset=None):
         period_filter, start_date, end_date = get_period(filter_by_period, timezone.zone)
         queryset = queryset.filter(**period_filter)
 
-    if extra:
-        queryset = queryset.extra(**extra)
-
     try:
         return await _run_results(
             queryset, on_field, additional_fields, calc, groups, order,

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi/client_ip.py

@@ -40,10 +40,18 @@ def get_client_ip(request):
 
     forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
     if forwarded_for:
-        # Leftmost is the client.
-        candidate = forwarded_for.split(',')[0].strip()
-        if candidate:
-            return candidate
+        # Walk right-to-left: the rightmost entries are appended by our
+        # own (trusted) proxies. The first entry that is NOT a trusted
+        # proxy is the real client. Taking the leftmost blindly let an
+        # attacker prepend a spoofed value to dodge IP rate limits.
+        parts = [p.strip() for p in forwarded_for.split(',') if p.strip()]
+        for candidate in reversed(parts):
+            if not _is_trusted(candidate):
+                return candidate
+        # Every hop was a trusted proxy — the client sits behind only
+        # our own proxies; the leftmost is the closest we have.
+        if parts:
+            return parts[0]
 
     real_ip = request.META.get('HTTP_X_REAL_IP')
     if real_ip:

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi/gen/config.py

@@ -26,21 +26,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any
 
-
-_SENSITIVE_EXACT = frozenset({
-    'password', 'pwd', 'passwd',
-    'secret', 'secret_key',
-    'api_key', 'api_secret',
-    'token', 'access_token', 'refresh_token',
-    'private_key', 'session_key',
-    'otp', 'otp_secret', 'two_factor_secret',
-    'token_password', 'token_user',
-})
-
-# Substring patterns are deliberately narrow — too eager and we'd flag
-# columns like ``force_password_reset`` (a boolean flag) as sensitive.
-_SENSITIVE_PREFIXES = ('password_', 'token_', 'secret_', 'api_key_', 'otp_')
-_SENSITIVE_SUFFIXES = ('_password', '_token', '_secret', '_api_key', '_apikey')
+from ..sensitive import looks_sensitive as _looks_sensitive
 
 
 _DJANGO_SYSTEM_PREFIXES = (
@@ -85,17 +71,6 @@ class Config:
     tables: dict[str, TableConfig] = field(default_factory=dict)
 
 
-def _looks_sensitive(column_name: str) -> bool:
-    name = column_name.lower()
-    if name in _SENSITIVE_EXACT:
-        return True
-    if any(name.startswith(p) for p in _SENSITIVE_PREFIXES):
-        return True
-    if any(name.endswith(s) for s in _SENSITIVE_SUFFIXES):
-        return True
-    return False
-
-
 def _is_django_system(db_table: str) -> bool:
     """Tables Django creates for itself (migrations, auth, sessions,
     admin, content types). Default to ``expose: false`` — the user can

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi/helpers.py

@@ -7,7 +7,7 @@ from django.core.exceptions import ObjectDoesNotExist
 from .exception import HTTPException
 
 
-LOCAL_HOST = re.compile(r'^(localhost|127.0.0.1):*([0-9]+)?$')
+LOCAL_HOST = re.compile(r'^(localhost|127\.0\.0\.1)(:[0-9]+)?$')
 
 re_id = re.compile(
     r'(.*)\/(?:'

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi/mcp/protocol.py

@@ -31,6 +31,7 @@ import logging
 
 from pydantic import BaseModel, ValidationError
 
+from ..sensitive import looks_sensitive
 from .schema import validate_input
 
 logger = logging.getLogger(__name__)
@@ -81,15 +82,16 @@ def _serialize_result(value, sensitive_fields=()):
         payload = [item.model_dump() for item in value]
     else:
         payload = value
-    if sensitive_fields:
-        _scrub(payload, set(sensitive_fields))
+    # Always scrub: the credential-name baseline applies even when the
+    # toolset declares no ``sensitive_fields``.
+    _scrub(payload, set(sensitive_fields))
     return payload
 
 
 def _scrub(obj, blocked):
     if isinstance(obj, dict):
         for key in list(obj.keys()):
-            if key in blocked:
+            if key in blocked or looks_sensitive(key):
                 obj.pop(key)
             else:
                 _scrub(obj[key], blocked)
@@ -237,9 +239,12 @@ async def handle_rpc(message, tools, request=None):
         else:
             return _rpc_error(rpc_id, JSONRPC_METHOD_NOT_FOUND,
                               f'Unknown method: {method}')
-    except Exception as exc:
+    except Exception:
+        # Log the full exception; return a generic message so internal
+        # detail (paths, SQL, field names) never reaches the client —
+        # mirrors the REST dispatch's sanitized 500.
         logger.exception('mcp.rpc.error method=%s', method)
-        return _rpc_error(rpc_id, JSONRPC_INTERNAL_ERROR, str(exc))
+        return _rpc_error(rpc_id, JSONRPC_INTERNAL_ERROR, 'Internal server error')
 
     if is_notification:
         return None
@@ -433,7 +438,9 @@ def _map_exception(exc):
         return 'METHOD_NOT_ALLOWED', message
     if status == 429:
         return 'RATE_LIMITED', message
-    return 'INTERNAL', message or 'Internal server error'
+    # Unmapped/unknown exception — never echo ``str(exc)`` to the client;
+    # the full exception is logged by the caller.
+    return 'INTERNAL', 'Internal server error'
 
 
 __all__ = ['handle_rpc', 'PROTOCOL_VERSION']

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi/oauth/clients.py

@@ -5,7 +5,11 @@ The project defines its clients under ``MCP['OAUTH_CLIENTS']``::
     MCP = {
         'OAUTH_CLIENTS': {
             'claude': {
-                'client_secret': os.environ['MCP_CLIENT_SECRET_CLAUDE'],
+                # Public client — MCP clients (Claude.ai, other LLMs)
+                # authenticate with PKCE, no shared secret. Required for
+                # dynamic registration (/register), which only provisions
+                # public clients.
+                'client_secret': None,
                 'redirect_uri': 'https://claude.ai/api/mcp/auth_callback',
                 'name': 'Claude',
             },
@@ -17,6 +21,10 @@ The project defines its clients under ``MCP['OAUTH_CLIENTS']``::
             },
         },
     }
+
+Confidential clients (``client_secret`` set) are still supported for
+the authorization-code/refresh grants, but are provisioned out of band
+— ``/register`` refuses to hand out their secret.
 """
 from .settings_helper import get_oauth_clients
 

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi/oauth/resources/register.py

@@ -9,16 +9,18 @@ from ..constants import GRANT_TYPE
 def _match_client(name):
     """Match the registration ``client_name`` to a configured client_id.
 
-    Looks up case-insensitively against each configured client's ``name``
-    field (substring match). Projects that need richer matching should
-    override this module.
+    Exact, case-insensitive match against each configured client's
+    ``name`` field. Substring matching was a security hole — an
+    unauthenticated caller could hit any configured client (and, in the
+    old code, extract its secret) by sending a ``client_name`` that
+    merely contained or was contained by the configured name. Projects
+    that need richer matching should override this module.
     """
-    name = (name or '').lower()
+    name = (name or '').strip().lower()
     if not name:
         return None
     for client_id, cfg in MCP_OAUTH_CLIENTS.items():
-        cfg_name = (cfg.get('name') or '').lower()
-        if cfg_name and (cfg_name in name or name in cfg_name):
+        if (cfg.get('name') or '').strip().lower() == name:
             return client_id
     return None
 
@@ -49,15 +51,29 @@ class Register(BaseResource):
             )
 
         client = MCP_OAUTH_CLIENTS[client_id]
+
+        # Dynamic registration only provisions public clients. A
+        # confidential client's secret is provisioned out of band (env)
+        # and MUST NOT be handed to an unauthenticated /register caller —
+        # doing so leaks the shared secret to anyone. Refuse instead of
+        # echoing it. MCP clients (Claude.ai, other LLMs) authenticate
+        # with PKCE, so a public client is the correct shape here.
+        if client.get('client_secret') is not None:
+            raise HTTPException(
+                400,
+                'invalid_client_metadata: dynamic registration is only '
+                'available for public clients; provision confidential '
+                'clients out of band',
+            )
+
         return {
             'client_id': client_id,
-            'client_secret': client['client_secret'],
             'client_id_issued_at': int(time.time()),
             'client_secret_expires_at': 0,
             'redirect_uris': [client['redirect_uri']],
             'grant_types': list(GRANT_TYPE.SUPPORTED),
             'response_types': ['code'],
-            'token_endpoint_auth_method': 'client_secret_basic',
+            'token_endpoint_auth_method': 'none',
             'application_type': application_type,
             'client_name': client['name'],
         }

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi/oauth/settings_helper.py

@@ -37,24 +37,32 @@ def get_oauth_scopes():
 def get_oauth_clients():
     """Dict ``client_id -> {client_secret, redirect_uri, name}``.
 
-    ``client_secret = None`` marks a public client (device flow).
-
-    Per-client secret defaults to ``MCP['OAUTH_SECRET']`` when the
-    entry's own ``client_secret`` is empty/missing — lets single-owner
-    deployments share one secret across all confidential clients
-    (Claude, ChatGPT, Gemini, ...) without listing it three times.
-    Set the entry's ``client_secret`` explicitly to override or to
-    rotate per-client.
+    Clients are **public by default**: an entry with no ``client_secret``
+    (or ``None``) is a public client — identity proven by PKCE, which is
+    the correct and safe shape for MCP clients (Claude.ai, ChatGPT,
+    Gemini, ...). Public is the default because ``/register`` is
+    unauthenticated: a public client has no secret to leak.
+
+    A client becomes **confidential** only by opting in explicitly:
+
+      * ``'client_secret': '<value>'`` — that literal secret, or
+      * ``'client_secret': ''``        — share ``MCP['OAUTH_SECRET']``
+        across confidential clients without repeating it (``None`` when
+        ``OAUTH_SECRET`` is unset).
+
+    ``client_secret`` is always normalized to be present (``None`` when
+    absent) so downstream lookups never ``KeyError``.
     """
     clients = dict(get_setting('OAUTH_CLIENTS', default={}) or {})
     fallback = get_setting('OAUTH_SECRET')
-    if not fallback:
-        return clients
     resolved = {}
     for client_id, conf in clients.items():
         conf = dict(conf or {})
-        if 'client_secret' not in conf or conf['client_secret'] == '':
-            conf['client_secret'] = fallback
+        secret = conf.get('client_secret')
+        if secret == '':
+            # Explicit opt-in to the shared confidential secret.
+            secret = fallback
+        conf['client_secret'] = secret
         resolved[client_id] = conf
     return resolved
 

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi/security.py

@@ -20,7 +20,7 @@ from .blocking import is_blocked
 from .client_ip import get_client_ip
 from .redis_config import KEY_PREFIX, get_redis
 
-from .settings_helper import get_setting
+from .settings_helper import get_setting, security_bypassed
 
 BLOCK_PATTERNS = get_setting('BLOCK_PATTERNS')
 BLOCK_USER_AGENTS = get_setting('BLOCK_USER_AGENTS')
@@ -104,12 +104,12 @@ class SecurityMiddleware:
             markcoroutinefunction(self)
 
     async def __call__(self, request):
-        # ``DEBUG = True`` projects skip every block path entirely —
-        # local dev cycles legitimately produce the kind of traffic
-        # patterns that would otherwise look abusive (404 sprees while
-        # wiring up routes, repeated 401s while testing auth).
-        from django.conf import settings as _django_settings
-        if getattr(_django_settings, 'DEBUG', False):
+        # Dev/bypass projects skip every block path entirely — local dev
+        # cycles legitimately produce traffic patterns that would look
+        # abusive (404 sprees while wiring up routes, repeated 401s while
+        # testing auth). Controlled by ``SECURITY_BYPASS`` (falls back to
+        # ``DEBUG`` when unset).
+        if security_bypassed():
             return await self.get_response(request)
 
         ip = get_client_ip(request)

easyapi_django-1.2.0/easyapi/sensitive.py

@@ -0,0 +1,37 @@
+"""Single source of truth for sensitive-field name detection.
+
+Used at generation time (pre-populating ``sensitive_fields`` on
+generated resources) and at runtime (baseline scrub in
+``BaseResource``/MCP serialization, applied regardless of the
+per-resource ``sensitive_fields`` list). Keeping one predicate means
+the framework's promise — never serialize a column that looks like a
+credential — holds even when a resource forgets to enumerate it.
+"""
+
+_SENSITIVE_EXACT = frozenset({
+    'password', 'pwd', 'passwd',
+    'secret', 'secret_key',
+    'api_key', 'api_secret',
+    'token', 'access_token', 'refresh_token',
+    'private_key', 'session_key',
+    'otp', 'otp_secret', 'two_factor_secret',
+    'token_password', 'token_user',
+})
+
+# Substring patterns are deliberately narrow — too eager and we'd flag
+# columns like ``force_password_reset`` (a boolean flag) as sensitive.
+_SENSITIVE_PREFIXES = ('password_', 'token_', 'secret_', 'api_key_', 'otp_')
+_SENSITIVE_SUFFIXES = ('_password', '_token', '_secret', '_api_key', '_apikey')
+
+
+def looks_sensitive(column_name):
+    if not isinstance(column_name, str):
+        return False
+    name = column_name.lower()
+    if name in _SENSITIVE_EXACT:
+        return True
+    if any(name.startswith(p) for p in _SENSITIVE_PREFIXES):
+        return True
+    if any(name.endswith(s) for s in _SENSITIVE_SUFFIXES):
+        return True
+    return False

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi/settings_helper.py

@@ -61,6 +61,33 @@ def get_read_only():
     return get_setting('READ_ONLY', default=False)
 
 
+def get_security_bypass():
+    """Explicit toggle to relax edge security + rate limiting.
+
+    ``None`` (default) → follow ``settings.DEBUG`` (historical behaviour:
+    a dev box with ``DEBUG=True`` skips blocking/rate-limit so local 404
+    sprees and auth retries don't self-inflict a 24h block).
+
+    Set ``True`` to force the bypass in a non-DEBUG environment, or
+    ``False`` to keep protections on even under ``DEBUG=True`` (e.g. a
+    staging box that mirrors production).
+    """
+    return get_setting('SECURITY_BYPASS', default=None)
+
+
+def security_bypassed():
+    """Resolve whether edge security + rate limiting are bypassed.
+
+    ``SECURITY_BYPASS`` wins when set; otherwise falls back to
+    ``settings.DEBUG``.
+    """
+    explicit = get_security_bypass()
+    if explicit is not None:
+        return bool(explicit)
+    from django.conf import settings as _django_settings
+    return bool(getattr(_django_settings, 'DEBUG', False))
+
+
 def get_metrics_max_execution_ms():
     """Server-side cap (milliseconds) for metrics aggregation queries,
     applied as a MySQL ``MAX_EXECUTION_TIME`` optimizer hint. The metrics

{easyapi_django-1.1.7 → easyapi_django-1.2.0/easyapi_django.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easyapi-django
-Version: 1.1.7
+Version: 1.2.0
 Summary: Zero-effort MCP server (and REST API) generator from Django models.
 Author-email: Stamatios Stamou Jr <bushier.outsets.0c@icloud.com>
 License-Expression: MIT
@@ -233,6 +233,10 @@ Defaults are demo-friendly. Production deployments should:
 - **Per-resource ownership.** Set `owner_field = 'owner_id'` on resources where rows belong to a single user — restricts every CRUD operation to the row's owner. `POST` always forces `owner_id` to the caller (override with `allow_owner_override = True` for admin paths).
 - **Authenticated cache.** If you turn on `cache = True` for an authenticated resource, set `session_cache = True` or `cache_scope_fields = (...)` — otherwise responses can leak across users. The framework warns at runtime when it detects this combination.
 - **Tune session TTLs.** `SESSION_TTL` (cookies, default 1800s) and `API_SESSION_TTL` (api-key cache, default 300s) both slide on use. Pick numbers that match your security/UX trade-off.
+- **Never ship `DEBUG = True`.** Under `DEBUG`, edge security (scanner blocking, 4xx flood detection), rate limiting, credential-path defense and abuse blocking are all bypassed for dev ergonomics. The framework logs a loud startup warning when the bypass is active. To decouple from `DEBUG` — e.g. a staging box mirroring production — set `MCP = {'SECURITY_BYPASS': False}` to force protections on (or `True` to bypass without `DEBUG`).
+- **Trust your proxies explicitly.** IP-based rate limits and abuse blocking key on the client IP. `X-Forwarded-For` / `X-Real-IP` are only honored when `REMOTE_ADDR` is in `TRUSTED_PROXIES = ['10.0.0.0/8', ...]`; otherwise `REMOTE_ADDR` wins. Leave it unset behind a proxy and every request looks like it comes from the proxy.
+- **Bound the metrics surface.** The `/metrics` endpoint queries any model in the registry by default. Set `METRICS_MODELS = ['app_Model', ...]` to allowlist which models are queryable. References to credential-named columns (in filters, groups, order or calc) are always rejected.
+- **OAuth clients are public by default.** MCP clients (Claude.ai, ChatGPT, ...) authenticate with PKCE — list them under `MCP['OAUTH_CLIENTS']` with no `client_secret`. A client becomes confidential only with an explicit secret; `/register` never hands out a confidential secret (provision those out of band).
 
 ---
 

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/easyapi_django.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ easyapi/redis_config.py
 easyapi/routes.py
 easyapi/schemas.py
 easyapi/security.py
+easyapi/sensitive.py
 easyapi/serializer.py
 easyapi/settings_helper.py
 easyapi/util.py

{easyapi_django-1.1.7 → easyapi_django-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "easyapi-django"
-version = "1.1.7"
+version = "1.2.0"
 authors = [
   { name="Stamatios Stamou Jr", email="bushier.outsets.0c@icloud.com" },
 ]