# Requête d'introspection : premier réflexe d'un attaquant contre une API GraphQL mal configurée
# Elle révèle TOUT le schéma (types, champs, mutations, arguments) sans authentification
query IntrospectionAttack {
  __schema {
    types {
      name
      fields {
        name
        args { name type { name } }
      }
    }
  }
}
# Contre-mesure : désactiver l'introspection en production (selon la lib GraphQL utilisée)

# Attaque par profondeur/complexité : une requête imbriquée peut exploser le coût CPU/DB (DoS applicatif)
query DeepAttack {
  user(id: 1) {
    friends {          # niveau 1
      friends {         # niveau 2
        friends {        # niveau 3 - et ainsi de suite, chaque niveau multiplie les résolutions
          friends { friends { friends { id } } }
        }
      }
    }
  }
}

# Défense en Python avec strawberry-graphql : limiter profondeur ET complexité, pas seulement l'une des deux
import strawberry
from strawberry.extensions import QueryDepthLimiter
from strawberry.extensions.field_extension import FieldExtension

schema = strawberry.Schema(
    query=Query,
    extensions=[
        QueryDepthLimiter(max_depth=6),          # rejette toute requête dépassant 6 niveaux d'imbrication
    ],
)
# Complexité : pondérer chaque champ (ex: liste = coût x taille max) et rejeter au-delà d'un budget total

# Batching attack : contourner un rate-limit HTTP en empilant N requêtes dans UNE seule requête GraphQL (alias)
query BruteforceViaAlias {
  attempt1: login(username: "admin", password: "pass1") { token }
  attempt2: login(username: "admin", password: "pass2") { token }
  attempt3: login(username: "admin", password: "pass3") { token }
  # ... répété 1000 fois -> 1000 tentatives dans une seule requête HTTP, invisible d'un rate-limiter naïf
}

# Défense : limiter le nombre d'alias par requête ET rate-limiter par coût de requête, pas par nombre de requêtes HTTP
def reject_too_many_aliases(document, max_aliases=20):
    alias_count = sum(1 for node in document if getattr(node, "alias", None))
    if alias_count > max_aliases:
        raise Exception("Trop d'alias dans une seule requête GraphQL")

# Autorisation au niveau champ (field-level), pas seulement au niveau requête
# Erreur classique : vérifier les droits sur la query "user" mais pas sur le champ imbriqué "user.salary"
import strawberry
from typing import Optional

def require_role(role: str):
    def decorator(resolver):
        def wrapped(root, info, **kwargs):
            current_user = info.context["request"].state.user
            if role not in current_user.roles:
                raise PermissionError(f"Rôle '{role}' requis pour ce champ")
            return resolver(root, info, **kwargs)
        return wrapped
    return decorator

@strawberry.type
class User:
    id: int
    name: str

    @strawberry.field
    @require_role("hr_admin")   # protège CE champ précis, indépendamment du reste de la requête
    def salary(self) -> Optional[float]:
        return self._salary