IDORIntermediate30 min de lecture2025-09-13
LANG:EN|FR

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
Reports Analyzed:
250
Platforms:
HackerOne
Research Timespan:
#IDOR#Autorisation#Sécurité API#Analyse de Masse#Impact Métier#GraphQL#Contrôle d'Accès#Services Financiers

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

🚨 RÉSULTATS DE RECHERCHE CRITIQUES
Analyse du Jeu de Données : 250 rapports IDOR divulgués sur HackerOne (2017–2025)
Impact Financier : Plus de 129 408 $ en primes analysées
Prime Individuelle la Plus Élevée : 20 000 $ (Import de Projet GitLab — Vol d'objets critique)
Découverte Critique : 36,4 % des IDORs classés Élevé ou Critique — l'IDOR n'est PAS une classe de bugs « à faible sévérité »

🔍 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.

📋 EXEMPLE TYPIQUE D'IDOR
# 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é
🧠 POURQUOI L'IDOR EST SI DANGEREUX
1. Invisible pour les scanners : L'IDOR se cache dans la logique métier — aucun outil automatisé ne le détecte de manière fiable
2. Exploitation triviale : Souvent, il suffit de changer une seule valeur de paramètre
3. Périmètre d'impact massif : Un seul IDOR peut exposer les données de chaque utilisateur dans une simple boucle d'énumération
4. Opérations d'écriture incluses : Pas seulement la lecture — les attaquants peuvent modifier, supprimer ou créer des ressources au nom d'autres utilisateurs

📊 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)

32
Critique
12,8 %
59
Élevé
23,6 %
111
Moyen
44,4 %
37
Faible
14,8 %

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.

💰 PRIME PAR SÉVÉRITÉ (Rapports Rémunérés Uniquement)
Critique : 14 333 $ de prime moyenne — Prise de contrôle de compte, vol d'objets, suppression massive
Élevé : 5 870 $ de prime moyenne — Suppression de contenu, accès non autorisé, exposition de PII
Moyen : 1 090 $ de prime moyenne — Accès limité aux données, manipulation de profil
Faible : 560 $ de prime moyenne — Divulgation d'informations, énumération

2. Tendances Temporelles — L'IDOR a Atteint son Pic en 2022, Toujours Présent

📈 DISTRIBUTION ANNÉE PAR ANNÉE

6
2017
17
2018
26
2019
46
2020
23
2021
50
2022
34
2023
31
2024
17
2025*
Pic : 2022 avec 50 rapports — porté par l'adoption API-first et la prolifération des apps mobiles
Pic de 2020 (46) : La transformation numérique rapide de l'ère COVID a introduit des lacunes d'autorisation
Plateau 2023-2025 : ~30 rapports/an indique que l'IDOR est endémique, pas épisodique
*Les données 2025 sont partielles (jusqu'en juin)

3. Programmes les Plus Ciblés

🎯 ORGANISATIONS LES PLUS CIBLÉES

🏛️ Dept of Defense28 rapports
📱 TikTok17 rapports
🔒 HackerOne17 rapports
💼 LinkedIn12 rapports
🦊 GitLab11 rapports
☁️ Nextcloud10 rapports
📝 Automattic9 rapports
☕ Starbucks8 rapports
🚗 Bykea7 rapports
💳 PayPal5 rapports

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
Voler les issues privées, MRs et notes de N'IMPORTE QUEL projet — incluant les secrets CI/CD, clés API et configs de déploiement
Les objets devenaient inaccessibles dans le projet original — causant des dysfonctionnements de pipeline
Les IDs séquentiels rendaient l'énumération triviale — pas besoin de connaître les IDs du projet cible
Affecte GitLab.com ET les installations auto-hébergées — chaque installation GitLab dans le monde était vulnérable
🔧 LE CORRECTIF & LEÇONS
Immédiat : GitLab a corrigé en v12.5.1 — la classe AttributeCleaner bloque désormais toutes les assignations _ids lors de l'import
Long terme : Passage d'une approche par liste noire à une approche par liste blanche pour les attributs d'import
Leçon : Les pipelines d'import/export sont un angle mort — ils contournent les flux d'autorisation API normaux

🔥 É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
Supprimer les vidéos Spotlight de N'IMPORTE QUEL utilisateur à distance — aucune interaction nécessaire
Détruire les flux de revenus : Les spotlights supprimés deviennent inéligibles aux paiements Crystal Awards
Cibler les influenceurs à grande échelle : Un attaquant pourrait systématiquement supprimer toute la bibliothèque de contenu d'un créateur
Aucun chemin de récupération : Le contenu supprimé était définitivement retiré
Sabotage concurrentiel : Des créateurs rivaux pourraient utiliser cela pour éliminer la concurrence
🔧 LE CORRECTIF
Validation de propriété côté serveur ajoutée à la mutation DeleteStorySnaps
Après correction, les tentatives de suppression non autorisées retournent : PermissionDenied: unable to delete snap
Leçon : Les opérations d'écriture (DELETE, UPDATE) nécessitent PLUS de contrôle que les opérations de lecture, pas moins

🔥 É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
N'acceptez jamais les décisions de triage initiales comme définitives — continuez à investiguer les cas limites
Le SSO introduit des hypothèses cachées : « l'utilisateur a un mot de passe » n'est pas toujours vrai
L'défaut d'association de session est subtile : Le serveur a authentifié l'utilisateur correctement, juste pas pour le bon compte
Chronologie de l'escalade : Informatif → rouvert → sévérité Élevée → 6 000 $. La persévérance paie.

⚔️ La Kill Chain IDOR

🔗 CYCLE DE VIE DE L'EXPLOITATION IDOR

PHASE 1 : RECONNAISSANCE

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.

PHASE 2 : MAPPING DES RÔLES

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).

PHASE 3 : TEST INTER-COMPTES

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).

PHASE 4 : ÉNUMÉRATION & ÉCHELLE

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).

PHASE 5 : DÉMONSTRATION D'IMPACT

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.

PHASE 6 : RAPPORT & ESCALADE

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)

Fréquence : Secteur le plus touché (11,2 %)
Prime Moy. : 0 $ (divulgation responsable)
Impacts Trouvés :
  • • 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
Risque : Sécurité nationale, violations FISMA

📱 RÉSEAUX SOCIAUX (TikTok 17, Snap 5, Reddit 5)

Fréquence : Cible majeure (10,8 %)
Prime Max : 15 000 $ (Snapchat)
Impacts Trouvés :
  • • 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
Risque : Perte de revenus des créateurs, érosion de la confiance

💼 LOGICIEL D'ENTREPRISE (GitLab 11, LinkedIn 12)

Fréquence : Cible à primes élevées (9,2 %)
Prime Max : 20 000 $ (GitLab)
Impacts Trouvés :
  • • Vol d'objets de projets privés
  • • Accès aux données inter-organisations
  • • Compromission de secrets CI/CD
  • • Manipulation de profils et identifiants
Risque : Compromission de la chaîne d'approvisionnement, vol de PI

💳 SERVICES FINANCIERS (PayPal, Stripe, Uber)

Fréquence : Cible à plus fort impact
Prime Max : 10 500 $ (PayPal)
Impacts Trouvés :
  • • 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
Risque : Fraude financière directe, violations PCI DSS

💰 Analyse d'Impact Financier

💵 ÉCONOMIE DES PRIMES

129 408 $+
Total Primes Divulguées
2 941 $
Prime Moy. (Payées)
20 000 $
Prime Individuelle Max
🏆 TOP 10 DES PRIMES IDOR
1. GitLab #743953 — Vol d'objets privés via import20 000 $
2. GitLab #767770 — Objets privés via import de projet20 000 $
3. Snapchat #1819832 — Supprimer le Spotlight de n'importe qui15 000 $
4. HackerOne #2122671 — Supprimer toutes les certifications12 500 $
5. PayPal #415081 — Ajouter des utilisateurs aux comptes business10 500 $
6. Mozilla #3154983 — Suppression de compte via SSO6 000 $
7. Uber #1145428 — Chaîne de 3 bugs charges arbitraires5 750 $
8. Shopify #2207248 — Accès facturation inter-boutiques5 000 $
9. Reddit #1658418 — Logs de modération de n'importe quel subreddit5 000 $
10. Reddit #1213237 — Supprimer tous les DMs sur RedditGifts5 000 $

💸 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é
Ne comptez pas sur les développeurs individuels pour se souvenir d'ajouter des vérifications. Rendez l'autorisation automatique.
# 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)
Le pattern le plus efficace : ne jamais récupérer une ressource sans scoper la 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
Le rate limiting seul : Ralentit l'énumération mais n'empêche pas l'accès
Les UUIDs seuls : Empêchent l'énumération mais pas le contournement d'autorisation — les UUIDs fuient dans les URLs, logs, messages d'erreur
La validation d'entrée : Valide le format mais pas l'autorisation
HTTPS : Chiffre le transport mais ne contrôle pas l'accès
Les vérifications côté client : Contournées par Burp Suite en quelques secondes

🧪 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=X peut 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

☐ Tester avec différents rôles (utilisateur, admin, modérateur, anonyme)
☐ Parcourir des plages d'IDs (vers le haut ET vers le bas depuis votre propre ID)
☐ Tester avec des IDs invalides/inexistants (vérifier les fuites dans les messages d'erreur)
☐ Vérifier toutes les opérations CRUD individuellement (GET, PUT, PATCH, DELETE, POST)
☐ Tester les requêtes authentifiées et non authentifiées
☐ Décoder les IDs base64/hex et chercher des patterns
☐ Vérifier l'introspection GraphQL pour les mutations cachées
☐ Chercher les fuites d'ID dans d'autres réponses (recherche, listes, erreurs)
☐ Tester la fonctionnalité d'import/export avec des fichiers fabriqués
☐ Tester les anciennes versions d'API (v1 vs v2 — implémentations d'auth différentes)

🔥 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

@jobert7 rapports
@datph4m6 rapports
@bugra6 rapports
@find_me_here5 rapports
@prakhar0x014 rapports
@a_d_a_m4 rapports
@ashwarya4 rapports
@sachin_kr4 rapports

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

Répartition Géographique
Asie du Sud (Inde, Pakistan, Bangladesh)~35 %
Europe (Allemagne, France, Pays-Bas)~25 %
Amérique du Nord (É.-U., Canada)~20 %
Moyen-Orient & Afrique~12 %
Asie de l'Est & Autres~8 %
Tendances Clés
• Plus de 150 chercheurs uniques sur 250 rapports
• Les meilleurs chasseurs se spécialisent dans le contrôle d'accès / autorisation
• Les découvertes répétées sur la même plateforme sont courantes (TikTok, DoD)
• Des employés de plateformes trouvant des bugs dans leur propre produit (HackerOne)

🔮 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. 1. Auditer tous les endpoints API pour la validation de propriété — prioriser les opérations d'écriture (DELETE, PUT)
  2. 2. Implémenter le scoping des requêtes — ajouter WHERE user_id = current_user à toutes les requêtes de ressources
  3. 3. Réviser le schéma GraphQL pour les mutations manquant d'autorisation au niveau des champs
  4. 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. 1. Déployer un middleware d'autorisation centralisé — rendre les vérifications de propriété automatiques, pas optionnelles
  2. 2. Remplacer les IDs séquentiels par des UUIDs pour tous les identifiants exposés en externe
  3. 3. Ajouter des tests spécifiques IDOR au CI/CD — tests automatisés d'accès inter-comptes
  4. 4. Conduire un audit import/export — vérifier que toutes les opérations en masse valident la propriété

🎯 LONG TERME (6+ mois)

  1. 1. Adopter le policy-as-code — définir les règles d'autorisation en politiques déclaratives (OPA/Rego)
  2. 2. Programme de champions sécurité — intégrer l'expertise en contrôle d'accès dans chaque équipe
  3. 3. Exercices réguliers de red team ciblant spécifiquement les frontières d'autorisation
  4. 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. 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. 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. 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. 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. 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.

[SHARE_THIS_POST]
Help spread knowledge in the cybersecurity community