IDOR dans la Nature : Analyse Complète de 250 Vulnérabilités Réelles

IDOR dans la Nature : Analyse Complète de 250 Vulnérabilités Réelles
🔍 Résumé Exécutif
L'Insecure Direct Object Reference (IDOR) reste la vulnérabilité d'autorisation la plus persistante dans les applications web modernes. À travers l'analyse de 250 rapports IDOR divulgués sur HackerOne entre 2017 et 2025, cette étude révèle que l'IDOR n'est ni rare ni en déclin — il a atteint un pic de 50 rapports en 2022 seul et continue à un rythme de 30+ rapports par an.
Notre analyse expose une vérité inconfortable : bien qu'étant conceptuellement simple (changer un ID, accéder aux données de quelqu'un d'autre), les vulnérabilités IDOR ont généré plus de 129 408 $ en primes divulguées, avec des rapports individuels atteignant 20 000 $. Les conséquences réelles vont bien au-delà des chiffres — de la suppression du contenu monétisé de n'importe quel créateur Snapchat (15 000 $) au vol de projets GitLab privés incluant les secrets CI/CD (20 000 $) en passant par l'ajout d'utilisateurs non autorisés aux comptes business PayPal (10 500 $).
Ce qui rend l'IDOR si redoutable, c'est son ratio simplicité/impact : un seul changement de paramètre peut compromettre l'ensemble du modèle d'autorisation d'une plateforme. Et contrairement aux attaques par corruption mémoire ou injection, les scanners automatisés détectent rarement les IDORs — ils se cachent dans la logique métier, attendant qu'un humain remarque que user_id=1234 peut devenir user_id=1235.
🎯 Qu'est-ce que l'IDOR ?
L'Insecure Direct Object Reference se produit quand les applications exposent des références directes à des objets internes (IDs de base de données, chemins de fichiers, identifiants utilisateur) sans vérifier que l'utilisateur demandeur est autorisé à y accéder. Contrairement aux chaînes d'exploitation complexes, l'IDOR est souvent trivialement exploitable — changez un nombre, accédez aux données de quelqu'un d'autre.
# Votre propre profil
GET /api/users/1234/profile HTTP/1.1
Authorization: Bearer YOUR_TOKEN
# L'attaquant change l'ID → accède aux données d'un autre
GET /api/users/1235/profile HTTP/1.1
Authorization: Bearer YOUR_TOKEN
# Le serveur renvoie le profil complet de la victime — aucune vérification de propriété
📊 Méthodologie d'Analyse
Cette étude examine 250 rapports IDOR divulgués depuis le Hacktivity de HackerOne, en se concentrant sur :
PORTÉE DE L'ANALYSE
- • Analyse temporelle : Tendances de 2017 à 2025
- • Schémas d'attaque : ID direct, défaut d'association de session, GraphQL, accès fichier
- • Secteurs d'industrie : Gouvernement, fintech, entreprise, réseaux sociaux
- • Impact financier : Distribution des primes par sévérité
SOURCES DE DONNÉES
- • 250 rapports HackerOne divulgués
- • Plus de 50 programmes de bug bounty uniques
- • Plus de 150 chercheurs en sécurité uniques
- • Vulnérabilités classifiées CWE-639
🔥 Résultats Clés
1. Distribution de Sévérité — L'IDOR Frappe Plus Fort Qu'on Ne le Croit
📊 RÉPARTITION PAR SÉVÉRITÉ (250 Rapports)
Constat clé : 36,4 % des vulnérabilités IDOR sont classées Élevé ou Critique. L'idée reçue « IDOR = faible sévérité » coûte cher aux organisations — les prises de contrôle de comptes, le vol massif de données et la fraude financière poussent significativement la sévérité vers le haut.
2. Tendances Temporelles — L'IDOR a Atteint son Pic en 2022, Toujours Présent
📈 DISTRIBUTION ANNÉE PAR ANNÉE
3. Programmes les Plus Ciblés
🎯 ORGANISATIONS LES PLUS CIBLÉES
Observation clé : Le DoD est en tête avec 28 rapports — les systèmes gouvernementaux avec des bases de code vieillissantes sont touchés de manière disproportionnée. Pendant ce temps, les 11 rapports de GitLab incluent les deux IDORs les mieux rémunérés du jeu de données (20 000 $ chacun).
🔬 Analyse Approfondie des Schémas d'Attaque
🎯 SCHÉMA 1 : MANIPULATION DIRECTE D'ID
Fréquence : 45 % des rapports
Méthode : Changer des IDs séquentiels/prévisibles dans l'URL ou le corps de requête
# Requête originale — votre réservation
GET /api/v1/bookings/8847?token=abc123
# L'attaquant incrémente le booking_id
GET /api/v1/bookings/8848?token=abc123
# Retourne : nom de la victime, téléphone, adresse, trajet
Exemple Réel — Bykea (#2374730) :
Exposition des noms, numéros de téléphone, adresses et détails de trajet de tous les clients pour n'importe quelle réservation
⚡ SCHÉMA 2 : DÉFAUT D'ASSOCIATION DE SESSION
Sévérité : Critique — prime moyenne la plus élevée (14K$+)
Méthode : Jeton d'auth valide, pas de vérification de propriété sur la ressource cible
POST /v1/account/destroy HTTP/1.1
Authorization: Bearer [ATTACKER_TOKEN]
Content-Type: application/json
{
"email": "victim@example.com",
"authPW": "deterministic_for_sso_users"
}
Mozilla (#3154983) : 6 000 $ — Supprimer N'IMPORTE QUEL compte Firefox (utilisateurs SSO = email seulement)
🔍 SCHÉMA 3 : ÉNUMÉRATION GRAPHQL
Tendance : En hausse rapide avec le développement API-first
Méthode : Exploiter les mutations GraphQL dépourvues d'autorisation au niveau des champs
mutation DeleteStorySnaps {
deleteStorySnaps(
ids: ["VICTIM_SNAP_ID"],
storyType: SPOTLIGHT_STORY
)
}
# Le serveur supprime le contenu monétisé de la victime
# Aucune vérification de propriété sur l'ID du snap
Snapchat (#1819832) : 15 000 $ — Supprimer le Spotlight de n'importe qui + tuer leurs revenus
📄 SCHÉMA 4 : ACCÈS FICHIER/DOCUMENT
Risque : Extrêmement élevé dans le gouvernement/entreprise
Méthode : Énumérer les IDs de fichiers dans les endpoints de téléchargement
GET /Download.aspx?id=4675 HTTP/1.1
# Retourne : document de personnel militaire
GET /Download.aspx?id=4676 HTTP/1.1
# Retourne : document suivant dans la séquence
# Aucune vérification d'autorisation sur la propriété du fichier
DoD (#1626508) : Documents de personnel militaire exposés via des IDs de téléchargement séquentiels
📦 SCHÉMA 5 : PIPELINE D'IMPORT/EXPORT
Impact : Critique — Vol de données inter-projets
Méthode : Créer des fichiers d'import malveillants avec des IDs d'objets étrangers
// project.json fabriqué à l'intérieur d'une archive tarball
{
"issue_ids": [27422144],
"issues": [],
"merge_request_ids": [99999]
}
// Import → vole les issues d'autres projets
GitLab (#743953) : 20 000 $ — Voler les issues, MRs et notes de n'importe quel projet via un import tarball fabriqué
🔗 SCHÉMA 6 : CHAÎNES DE VULNÉRABILITÉS
Complexité : Avancée — plusieurs bugs combinés
Méthode : Chaîner 2+ IDORs ou IDOR + contournement d'auth pour un impact maximal
Chaîne : IDOR #1 → énumérer les IDs de vouchers
+ IDOR #2 → modifier la cible du voucher
+ Contournement d'auth → appliquer à n'importe quel compte
= Charges arbitraires sur n'importe quelle entreprise
Uber (#1145428) : 5 750 $ — Chaîne de 3 bugs → charges arbitraires sur n'importe quelle carte de crédit U4B
🔥 Étude de Cas #1 : Import de Projet GitLab → 20 000 $
ÉTUDE DE CAS : VOLER DES OBJETS PRIVÉS VIA L'IMPORT DE PROJET
Rapport #743953 | Rapporteur : saltyyolk | Prime : 20 000 $ (1K$ initial + 19K$ bonus) | Sévérité : Critique
🎯 L'ATTAQUE
La fonctionnalité d'import de projet de GitLab accepte des archives tarball contenant un fichier project.json qui définit la structure du projet. Le chercheur a découvert que les attributs de clés étrangères comme issue_ids, merge_request_ids, note_ids et board_ids n'étaient pas exclus lors du traitement de l'import.
En fabriquant un tarball malveillant avec une modification stratégique :
{
"description": "Projet de l'attaquant",
"issue_ids": [27422144],
"issues": [],
"merge_request_ids": [12345678],
"merge_requests": []
}
Le processus d'import appelait @project.assign_attributes(project_params) dans project_tree_restorer.rb, qui acceptait aveuglément ces tableaux de clés étrangères. Le résultat : les issues, merge requests, notes et boards d'autres projets étaient silencieusement transférés vers le projet de l'attaquant.
💥 L'IMPACT
🔧 LE CORRECTIF & LEÇONS
AttributeCleaner bloque désormais toutes les assignations _ids lors de l'import🔥 Étude de Cas #2 : Snapchat Spotlight → 15 000 $
ÉTUDE DE CAS : SUPPRIMER LE CONTENU SPOTLIGHT MONÉTISÉ DE N'IMPORTE QUI
Rapport #1819832 | Rapporteur : prickn9 (Sahil Saxena) | Prime : 15 000 $ | Sévérité : Élevée
🎯 L'ATTAQUE
Le Spotlight de Snapchat est la réponse de la plateforme à TikTok — les créateurs publient de courtes vidéos et gagnent de l'argent via les « Crystal Awards » basés sur l'engagement. Le chercheur a découvert que la mutation GraphQL pour supprimer le contenu Spotlight n'avait aucune validation de propriété.
L'attaque était d'une simplicité dévastatrice :
POST /graphql HTTP/1.1
Content-Type: application/json
Cookie: [ATTACKER_SESSION]
{
"operationName": "DeleteStorySnaps",
"variables": {
"ids": ["VICTIM_SPOTLIGHT_VIDEO_ID"],
"storyType": "SPOTLIGHT_STORY"
},
"query": "mutation DeleteStorySnaps($ids: [String!]!, $storyType: StoryType!) {
deleteStorySnaps(ids: $ids, storyType: $storyType)
}"
}
L'attaquant intercepte simplement sa propre requête de suppression dans Burp Suite, remplace le tableau ids par l'ID vidéo de la victime cible, et la transmet. Le serveur ne vérifie jamais si l'utilisateur demandeur possède le contenu.
💥 L'IMPACT — AU-DELÀ DES DONNÉES
🔧 LE CORRECTIF
DeleteStorySnapsPermissionDenied: unable to delete snap🔥 Étude de Cas #3 : Mozilla Firefox → 6 000 $ (L'Histoire de l'Escalade)
ÉTUDE DE CAS : SUPPRESSION DE COMPTE VIA DÉFAUT D'ASSOCIATION DE SESSION + CONTOURNEMENT SSO
Rapport #3154983 | Rapporteur : z3phyrus | Prime : 6 000 $ | Sévérité : Élevée (initialement fermé comme Informatif !)
🎯 LA DÉCOUVERTE INITIALE
Le endpoint API Firefox Accounts /v1/account/destroy acceptait deux paramètres : email et authPW (hash du mot de passe). Le serveur validait que les identifiants étaient corrects — mais ne vérifiait jamais que la session authentifiée appartenait au compte en cours de suppression.
POST /v1/account/destroy HTTP/1.1
Authorization: Bearer [ATTACKER_SESSION_TOKEN]
Content-Type: application/json
{
"email": "victim@example.com",
"authPW": "42b4c2940fe2efecce851a2d8e9754d0f1cb1d37..."
}
Initialement, Mozilla a fermé cela comme Informatif : « Si l'attaquant a l'email et le mot de passe de la victime, ce n'est pas une vulnérabilité. »
🚀 L'ESCALADE — LES UTILISATEURS SSO N'ONT PAS DE MOT DE PASSE
Le chercheur n'a pas abandonné. Il a découvert que les utilisateurs SSO (connexion Google) qui n'ont jamais défini de mot de passe partagent une valeur authPW déterministe. Cela signifiait :
Prérequis de l'attaque pour les utilisateurs SSO :
1. Connaître l'adresse email de la victime ← trivial, souvent public
2. authPW est déterministe ← identique pour tous les utilisateurs SSO sans mot de passe
3. Utiliser le propre jeton de session de l'attaquant
Résultat : Supprimer N'IMPORTE QUEL compte Firefox d'un utilisateur SSO
→ Tous les favoris, mots de passe, historique synchronisés = DISPARUS
Le rapport a été rouvert, mis à niveau d'Informatif à sévérité Élevée, et récompensé de 6 000 $.
💡 LA MÉTA-LEÇON
⚔️ La Kill Chain IDOR
🔗 CYCLE DE VIE DE L'EXPLOITATION IDOR
Cartographier la surface API de l'application. Identifier les endpoints qui acceptent des identifiants d'objets : user_id, booking_id, document_id, order_id. Chercher les entiers séquentiels, valeurs encodées en base64 ou UUIDs. L'introspection GraphQL révèle les identifiants au niveau des champs.
Créer 2+ comptes avec des rôles différents (utilisateur, admin, modérateur). Documenter les objets auxquels chaque rôle peut accéder. Noter les IDs assignés aux ressources de chaque compte — cela révèle le pattern d'ID (séquentiel, UUID, base64).
Utiliser la session du Compte A pour accéder aux ressources du Compte B. Tester toutes les opérations CRUD : Pouvez-vous lire les données de B ? Les modifier ? Les supprimer ? Créer des ressources sous l'espace de B ? Chaque verbe peut avoir des contrôles d'autorisation différents (ou en manquer).
Si les IDs sont séquentiels, parcourir des plages de valeurs. Mesurer le rayon d'explosion : combien d'utilisateurs/objets sont accessibles ? Pour les IDs base64, décoder et chercher des patterns. Pour les UUIDs, vérifier s'ils sont divulgués dans d'autres réponses (résultats de recherche, réponses API, messages d'erreur).
Allez au-delà de « je peux voir le profil de l'utilisateur #2 ». Montrez l'impact réel : exposition de PII (noms, emails, numéros de téléphone), données financières (factures, détails de paiement), opérations d'écriture (suppression de compte, manipulation de données). Documentez la chaîne d'un accès trivial à un impact métier critique.
Rédigez un PoC clair. Si l'évaluation initiale est de faible sévérité, cherchez des chemins d'escalade : Pouvez-vous chaîner avec un autre bug ? Y a-t-il des opérations d'écriture ? Cela affecte-t-il des données financières/de conformité ? Le rapport Mozilla est passé d'Informatif à 6 000 $ grâce à l'escalade.
🧱 Analyse des Causes Racines
⚠️ ANALYSE DES CAUSES RACINES PRINCIPALES
1. Validation de Propriété Manquante (78 % des cas)
L'authentification est présente mais la vérification de propriété est absente. Le serveur confirme « c'est un utilisateur valide » mais ne demande jamais « cet utilisateur possède-t-il cette ressource ? »
# VULNÉRABLE — authentifie mais n'autorise pas
@require_authentication
def get_booking(booking_id):
return database.get_booking_by_id(booking_id) # Pas de vérification de propriété !
# SÉCURISÉ — authentifie ET autorise
@require_authentication
def get_booking(booking_id, current_user):
booking = database.get_booking_by_id(booking_id)
if booking.user_id != current_user.id:
raise PermissionDenied("Pas votre réservation")
return booking
2. Identifiants d'Objets Prévisibles (65 % des cas)
Entiers séquentiels, IDs auto-incrémentés en base de données ou valeurs base64 facilement décodables rendent l'énumération triviale
// VULNÉRABLE — Les IDs séquentiels sont trivialement énumérables
const orderId = 1001; // Prochaine commande = 1002, 1003...
// MIEUX — Les UUIDs empêchent l'énumération (mais nécessitent toujours des vérifications de propriété !)
const orderId = "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
// Les UUIDs ne REMPLACENT PAS l'autorisation — c'est de la défense en profondeur
3. Autorisation Incohérente Entre les Endpoints (45 % des cas)
Certains endpoints valident correctement l'accès tandis que d'autres — souvent les APIs internes, panneaux d'admin ou fonctionnalités plus récentes — sont oubliés
# Endpoint SÉCURISÉ — valide la propriété
GET /api/users/profile ✓ Vérifie la propriété de session
# Endpoint VULNÉRABLE — même ressource, chemin différent
GET /api/users/{id}/orders ✗ Validation manquante
GET /bugs.json?org_id={id} ✗ Endpoint de recherche oublié
4. Sécurité Côté Client Uniquement (23 % des cas)
Le frontend cache les ressources que l'utilisateur ne devrait pas voir, mais l'API les renvoie quand même quand on les demande directement
// VULNÉRABLE — Vérification côté client uniquement
if (currentUser.id === resourceOwnerId) {
showDeleteButton(); // Caché ≠ Protégé
}
// Le endpoint API DELETE n'a aucune vérification
// Burp Suite contourne cela en quelques secondes
🏭 Analyse d'Impact par Industrie
🏛️ GOUVERNEMENT & DÉFENSE (28 rapports)
- • Exposition de données de personnel militaire
- • Suppression d'images de profil à travers les systèmes
- • Accès aux données démographiques via IDs séquentiels
- • Téléchargement de documents sans autorisation
📱 RÉSEAUX SOCIAUX (TikTok 17, Snap 5, Reddit 5)
- • Suppression de contenu / sabotage concurrentiel
- • Accès aux descriptions de vidéos privées
- • Énumération de tickets de support
- • Suppression de DMs entre comptes
💼 LOGICIEL D'ENTREPRISE (GitLab 11, LinkedIn 12)
- • Vol d'objets de projets privés
- • Accès aux données inter-organisations
- • Compromission de secrets CI/CD
- • Manipulation de profils et identifiants
💳 SERVICES FINANCIERS (PayPal, Stripe, Uber)
- • Ajout non autorisé d'utilisateurs aux comptes business
- • Charges arbitraires sur cartes de crédit
- • Accès inter-tenants aux documents de facturation
- • Annulation de ventes sans autorisation
💰 Analyse d'Impact Financier
💵 ÉCONOMIE DES PRIMES
🏆 TOP 10 DES PRIMES IDOR
💸 COÛTS DIRECTS
- • Paiements de primes : 129K$+ sur 44 rapports payés
- • Réponse aux incidents : 1,76M$ coût moyen (IBM 2023)
- • Amendes réglementaires : RGPD jusqu'à 4 % du chiffre d'affaires
⚙️ IMPACT OPÉRATIONNEL
- • 82 % des rapports sans prime — divulgation responsable
- • Résolution moy. : 4,2 mois jusqu'à la divulgation
- • Systèmes gouvernementaux : jusqu'à 14 mois de résolution
📉 ATTEINTE À LA RÉPUTATION
- • 67 % des utilisateurs partent après une fuite de données
- • Confiance plateforme : HackerOne a trouvé des IDORs sur sa propre plateforme (17 rapports)
- • Risque concurrentiel : Suppression Spotlight Snapchat = exode des créateurs
🛡️ Stratégies de Prévention
🔒 PATTERNS DE DÉFENSE QUI FONCTIONNENT
1. Middleware d'Autorisation Centralisé
# Middleware d'autorisation — TOUTES les routes passent par là
class OwnershipMiddleware:
def process_request(self, request, resource_type, resource_id):
resource = get_resource(resource_type, resource_id)
if resource.owner_id != request.user.id:
if not request.user.has_role('admin'):
raise PermissionDenied(
f"L'utilisateur {request.user.id} ne peut pas accéder à "
f"{resource_type}/{resource_id}"
)
# Log d'audit pour chaque accès
audit_log(request.user.id, resource_type, resource_id, 'access')
2. Requêtes Scopées à l'Utilisateur Courant (Défense au Niveau Requête)
# VULNÉRABLE — récupère n'importe quelle réservation puis vérifie
booking = Booking.objects.get(id=booking_id)
if booking.user != request.user: raise PermissionDenied()
# SÉCURISÉ — la requête est scopée dès le départ
booking = Booking.objects.get(id=booking_id, user=request.user)
# Si l'utilisateur ne la possède pas → DoesNotExist → 404
# Aucun IDOR possible — la requête elle-même impose la propriété
3. Contrôle d'Accès Basé sur les Ressources (RBAC)
# Définition de politique
resource: booking
actions: [read, update, delete]
rules:
- condition: resource.user_id == request.user.id
effect: allow
- condition: request.user.role == 'admin'
effect: allow
- default: deny
4. Ce Qui NE Corrige PAS l'IDOR
🧪 Méthodologie pour les Chasseurs de Bugs
🛠️ GUIDE SYSTÉMATIQUE DE CHASSE AUX IDOR
Étape 1 : Configuration — Deux Comptes Minimum
Créez le Compte A (attaquant) et le Compte B (victime). Des rôles différents si possible : utilisateur standard, admin, modérateur. Notez les IDs assignés aux ressources de chaque compte.
Étape 2 : Cartographier Chaque Endpoint
Utilisez Burp Suite pour spider l'app. Exportez le sitemap. Cherchez tout paramètre qui ressemble à un ID : id, user_id, uid, profile_id, booking_id, order_id, doc_id. Vérifiez le corps de requête, le chemin URL, les query params et les headers.
Étape 3 : Tester les 4 Opérations CRUD
Pour chaque paramètre d'ID identifié, testez avec le jeton du Compte A mais l'ID de ressource du Compte B :
- GET — Pouvez-vous lire les données de B ?
- PUT/PATCH — Pouvez-vous modifier les données de B ?
- DELETE — Pouvez-vous supprimer les ressources de B ?
- POST — Pouvez-vous créer des ressources sous l'espace de B ?
Étape 4 : Vérifier les Surfaces Non Évidentes
- • GraphQL : Vérifiez les mutations ET les queries — utilisez l'introspection pour trouver les champs cachés
- • Import/Export : Fabriquez des fichiers d'import malveillants avec des IDs étrangers (pattern GitLab)
- • Webhooks & Callbacks : Souvent sans autorisation du tout
- • Endpoints de recherche :
/search?org_id=Xpeut contourner les contrôles d'accès normaux - • Panneaux d'admin : Les outils internes ont souvent des vérifications plus faibles
- • APIs mobiles : Les versions plus anciennes peuvent manquer de middleware d'autorisation
📋 CHECKLIST DE TEST IDOR
🔥 CHEATSHEET DES PARAMÈTRES IDOR
# Noms de paramètres à haute valeur à tester
user_id, id, uid, user, profile_id, account_id, member_id
booking_id, order_id, transaction_id, payment_id, invoice_id
document_id, file_id, attachment_id, media_id, asset_id
project_id, org_id, team_id, workspace_id, tenant_id
report_id, ticket_id, case_id, issue_id, request_id
comment_id, note_id, message_id, thread_id, conversation_id
certification_id, license_id, credential_id, badge_id
# Patterns spécifiques GraphQL
node(id: "base64_encoded_global_id")
mutation { deleteResource(id: "VICTIM_ID") }
query { user(id: VICTIM_INT) { privateField } }
# Patterns d'IDs encodés à décoder
base64: eyJ1c2VyX2lkIjoxMjM0fQ== → {"user_id": 1234}
hex: 0x4D2 → 1234
uuid: vérifier si séquentiel ou vraiment aléatoire
👥 Profils des Chercheurs & Répartition Géographique
🏆 TOP CHASSEURS D'IDOR
Notable : @jobert (co-fondateur de HackerOne) est en tête avec 7 — dont beaucoup trouvés sur la propre plateforme de HackerOne. @bugbountywithmarco se spécialise dans les IDORs transport/covoiturage.
🌍 DÉMOGRAPHIE DES CHERCHEURS
🔮 Tendances Futures et Menaces Émergentes
⚠️ PAYSAGE ÉMERGENT DES MENACES IDOR
1. GraphQL & Architectures API-First
La flexibilité de GraphQL est une arme à double tranchant. Les requêtes imbriquées peuvent accéder à plusieurs ressources en une seule requête, et l'autorisation au niveau des champs est plus difficile à imposer que les contrôles au niveau des endpoints. Nos données montrent que les rapports IDOR GraphQL augmentent d'année en année.
Tendance : 2020-2022 a vu 5 IDORs GraphQL ; 2023-2025 en a vu 12+ — une augmentation de 140 %
2. Lacunes d'Autorisation dans les Microservices
Dans les architectures microservices, chaque service peut implémenter sa propre logique d'autorisation (ou oublier de le faire). Les passerelles API valident l'authentification mais transmettent souvent les IDs de ressources sans vérification de propriété. La communication inter-services fonctionne fréquemment avec des privilèges élevés.
Exemple : La chaîne de 3 bugs d'Uber exploitait des lacunes entre les services voucher, paiement et business
3. Applications Alimentées par l'IA
Les assistants IA qui accèdent aux données utilisateur créent de nouvelles surfaces IDOR. Si un chatbot peut interroger les commandes d'un utilisateur, peut-il être trompé pour interroger les commandes d'autres utilisateurs ? Les serveurs MCP (Model Context Protocol) qui interagissent avec les APIs au nom des utilisateurs introduisent des vecteurs IDOR basés sur les outils.
Risque : Les appels d'outils IA peuvent contourner entièrement le middleware d'autorisation traditionnel
4. Divergence des APIs d'Applications Mobiles
Les applications mobiles utilisent souvent des versions d'API différentes des applications web. Les anciens endpoints d'API mobile peuvent manquer de mises à jour d'autorisation appliquées à la version web. Le reverse engineering d'applications mobiles révèle des endpoints codés en dur ou zombies (comme les endpoints de Bykea inutilisés mais toujours accessibles).
Exemple : Bykea #3085742 — IDOR sur un endpoint zombie codé en dur trouvé via reverse engineering de l'app Android
🏢 Recommandations pour les Organisations
🚨 ACTIONS IMMÉDIATES (0-30 jours)
- 1. Auditer tous les endpoints API pour la validation de propriété — prioriser les opérations d'écriture (DELETE, PUT)
- 2. Implémenter le scoping des requêtes — ajouter
WHERE user_id = current_userà toutes les requêtes de ressources - 3. Réviser le schéma GraphQL pour les mutations manquant d'autorisation au niveau des champs
- 4. Ajouter de l'audit logging pour toutes les tentatives d'accès aux ressources (détecter l'énumération)
⚡ MOYEN TERME (1-6 mois)
- 1. Déployer un middleware d'autorisation centralisé — rendre les vérifications de propriété automatiques, pas optionnelles
- 2. Remplacer les IDs séquentiels par des UUIDs pour tous les identifiants exposés en externe
- 3. Ajouter des tests spécifiques IDOR au CI/CD — tests automatisés d'accès inter-comptes
- 4. Conduire un audit import/export — vérifier que toutes les opérations en masse valident la propriété
🎯 LONG TERME (6+ mois)
- 1. Adopter le policy-as-code — définir les règles d'autorisation en politiques déclaratives (OPA/Rego)
- 2. Programme de champions sécurité — intégrer l'expertise en contrôle d'accès dans chaque équipe
- 3. Exercices réguliers de red team ciblant spécifiquement les frontières d'autorisation
- 4. Revue d'architecture multi-tenant — assurer l'isolation complète des données entre les tenants
🎯 Conclusion
📊 ANALYSE FINALE
L'IDOR est la classe de vulnérabilités qui refuse de mourir. Notre analyse de 250 rapports HackerOne entre 2017 et 2025 révèle un problème persistant et endémique : bien qu'étant l'un des concepts de vulnérabilité les plus simples à comprendre, l'IDOR continue d'affecter les plateformes de toute taille et industrie à un rythme de 30+ rapports divulgués par an.
Points Clés à Retenir :
- 1. L'IDOR n'est PAS de faible sévérité : 36,4 % des rapports sont Élevé/Critique. La prime moyenne d'un IDOR de sévérité critique est de 14 333 $ — c'est une classe de bugs sérieuse.
- 2. Les opérations d'écriture sont le vrai danger : Les rapports GitLab à 20K$, Snapchat à 15K$ et Mozilla à 6K$ impliquaient tous des opérations d'écriture/suppression — pas seulement de la lecture de données.
- 3. Des surfaces d'attaque non évidentes existent : Les pipelines d'import/export, mutations GraphQL, endpoints mobiles zombies et fonctionnalités de recherche sont fréquemment oubliés par les développeurs.
- 4. La solution est l'ingénierie, pas l'outillage : Aucun scanner ne détecte fiablement l'IDOR. Un middleware d'autorisation centralisé avec scoping au niveau des requêtes est la seule solution systémique.
- 5. La persévérance gagne pour les chasseurs : Le rapport Mozilla est passé d'« Informatif » à 6 000 $ grâce à la recherche d'escalade. N'acceptez jamais la première décision de triage.
La Voie à Suivre :
La défense la plus efficace contre l'IDOR n'est pas un outil ou une checklist — c'est une décision architecturale. Restreignez chaque requête de base de données à l'utilisateur courant. Rendez le middleware d'autorisation obligatoire, pas optionnel. Considérez chaque identifiant d'objet comme une entrée non fiable. Les organisations qui imposent systématiquement ces patterns voient leur taux de rapports IDOR chuter à quasi zéro. Les autres continuent de payer des primes.
Pour les Chasseurs de Bugs :
L'IDOR reste l'une des classes de vulnérabilités les plus accessibles et les plus gratifiantes à chasser. La clé pour des primes plus élevées : ne vous arrêtez pas à prouver l'accès. Montrez le rayon d'explosion — combien d'utilisateurs sont affectés ? Pouvez-vous écrire, pas seulement lire ? Cela s'enchaîne-t-il avec un autre bug ? La différence entre un rapport IDOR à 500 $ et un à 20 000 $ est l'impact que vous démontrez.
Cette analyse est basée sur 250 rapports de vulnérabilités IDOR publiquement divulgués sur HackerOne, couvrant plus de 50 programmes de bug bounty uniques de 2017 à 2025. Elle représente un sous-ensemble des vulnérabilités IDOR réelles — de nombreuses découvertes restent non divulguées ou ont été signalées via des programmes privés.
Cette recherche a été principalement conduite avec l'assistance de l'IA pour améliorer la clarté et la structure.