apidetector

Présenté au BlackHat Arsenal 2024 (Lien)

Historique des versions

Nouveautés de la version 3 (actuelle)

• Interface Web moderne : interface conviviale pour un scan facile des points d'accès API
• Résultats en temps réel : mises à jour en direct des points d'accès et vulnérabilités découverts
• Tableau de bord interactif : interface propre et réactive utilisant Tailwind CSS et Alpine.js
• Support du téléchargement de fichiers : scanner plusieurs domaines/sous-domaines à la fois en téléchargeant un fichier texte
• Validation des domaines : validation des entrées par correspondance de motifs regex
• Configuration flexible : formulaire facile à utiliser pour les paramètres de scan avec des valeurs par défaut améliorées
• Résultats visuels : présentation améliorée des résultats de scan et des PoC
• Gestion des captures d'écran : capture et affichage automatiques des captures d'écran des points d'accès vulnérables (une par sous-domaine)
• Génération ciblée de PoC : génération de preuve de concept uniquement pour les points d'accès /swagger-ui/index.html
• Design responsive : optimisé pour toutes les tailles d'écran, du mobile au desktop
• Gestion des erreurs : rétroaction et journalisation améliorées des erreurs
• Améliorations de l'accessibilité : meilleure navigation au clavier et support des lecteurs d'écran

Fonctionnalités de la version 2

• Détection automatique XSS : identifie les versions Swagger vulnérables
• Génération visuelle de PoC : crée des preuves de concept pour les vulnérabilités
• Gestion améliorée des erreurs : meilleure rétroaction et journalisation
• Performance améliorée : algorithmes de scan optimisés

Fonctionnalités de base

• Entrée flexible : accepte des domaines uniques ou des listes de sous-domaines
• Protocoles multiples : teste les points d'accès sur HTTP et HTTPS
• Concurrence : scan multi-threadé pour des résultats plus rapides
• Détection intelligente : capacités avancées de détection de faux positifs
• Paramètres personnalisables : configurer les threads, le user-agent, etc.

Prérequis

APIDetector v3 nécessite Python 3.x et les paquets suivants :

flask         # Framework web
requests      # Client HTTP
playwright    # Automatisation du navigateur pour les captures d'écran
nest_asyncio  # Support async IO

Toutes les dépendances sont listées dans requirements.txt et peuvent être installées automatiquement lors de la configuration.

Configuration initiale

Après avoir installé les paquets requis, vous devez installer les navigateurs Playwright :

python -m playwright install

Ceci est nécessaire pour le bon fonctionnement de la fonctionnalité de capture d'écran.

Premiers pas

Prérequis

• Python 3.x (Télécharger)
• pip (installateur de paquets Python)
• Git (pour cloner le dépôt)

Installation

1. Clonez le dépôt :

git clone https://github.com/brinhosa/apidetector.git
cd apidetector

2. Créez et activez un environnement virtuel :

# Sur macOS/Linux :
python3 -m venv venv
source venv/bin/activate

# Sur Windows :
python -m venv venv
venv\Scripts\activate

3. Installez les dépendances :

pip install -r requirements.txt

4. Installez l'automatisation du navigateur :

playwright install

Interface Web (Version 3)

1. Démarrez le serveur web :

python app.py

2. Par défaut, le serveur tourne sur http://127.0.0.1:5000. Vous pouvez spécifier un port ou un hôte différent :

python app.py --port 8080 --host 0.0.0.0

3. Ouvrez votre navigateur et accédez à l'URL affichée dans le terminal.

4. Utilisation de l'interface web :

   • Saisissez un seul domaine ou téléchargez un fichier contenant plusieurs domaines (un par ligne)
   • Configurez les options de scan (nombre de threads, mode mixte, user-agent)
   • Cliquez sur 'Démarrer le scan' pour commencer
   • Visualisez les résultats en temps réel au fur et à mesure
   • Les captures d'écran des points d'accès vulnérables s'affichent automatiquement

5. Les captures d'écran sont enregistrées dans le répertoire screenshots pour référence ultérieure.

Utilisation

APIDetector v3 offre deux façons d'interagir avec l'outil : une interface web moderne (nouveauté de la v3) et une interface en ligne de commande traditionnelle (originale).

Interface Web

1. Démarrez le serveur web :

python app.py [options]

Options disponibles :

Exemples :

# Exécution avec les paramètres par défaut (localhost:5000)
python app.py

# Exécution sur un port personnalisé
python app.py -p 8080

# Autoriser l'accès externe
python app.py --host 0.0.0.0

# Exécution en mode débogage
python app.py -d

2. Accédez à l'interface web :

   • Ouvrez votre navigateur et accédez à l'URL affichée
   • Saisissez le domaine cible OU téléchargez un fichier contenant plusieurs domaines (un par ligne)
   • Configurez les options de scan :
     • Mode HTTP/HTTPS
     • Nombre de threads (défaut : 10)
     • User-Agent personnalisé
   • Cliquez sur "Démarrer le scan"

3. Visualisez les résultats :

   • Les points d'accès API découverts sont affichés en temps réel avec suivi de la progression
   • Les points d'accès vulnérables sont automatiquement testés
   • Des captures d'écran de PoC sont générées pour les vulnérabilités confirmées
   • Les résultats peuvent être consultés pendant que le scan est encore en cours

Interface en Ligne de Commande

Exécutez APIDetector en ligne de commande. Voici quelques exemples d'utilisation :

• Usage courant : scanner une liste de sous-domaines avec 30 threads en utilisant un user-agent Chrome et enregistrer les résultats dans un fichier :

  root@kitploit:~

  python apidetector.py -i list_of_company_subdomains.txt -o results_file.txt -t 30 -ua "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36"
  

• Pour scanner un seul domaine :

  root@kitploit:~

  python apidetector.py -d example.com
  

• Pour scanner plusieurs domaines à partir d'un fichier :

  root@kitploit:~

  python apidetector.py -i input_file.txt
  

• Pour spécifier un fichier de sortie :

  root@kitploit:~

  python apidetector.py -i input_file.txt -o output_file.txt
  

• Pour utiliser un nombre spécifique de threads :

  root@kitploit:~

  python apidetector.py -i input_file.txt -t 20
  

• Pour scanner avec les deux protocoles HTTP et HTTPS :

  root@kitploit:~

  python apidetector.py -m -d example.com
  

• Pour exécuter le script en mode silencieux (supprimer la sortie verbose) :

  root@kitploit:~

  python apidetector.py -q -d example.com
  

Si vous utilisez APIDetector v2, remplacez les commandes par apidetectorv2.py.

Options

• -d, --domain : Domaine unique à tester.
• -i, --input : Fichier d'entrée contenant les sous-domaines à tester.
• -o, --output : Fichier de sortie pour écrire les URL valides.
• -t, --threads : Nombre de threads à utiliser pour le scan (défaut : 10).
• -m, --mixed-mode : Tester les protocoles HTTP et HTTPS.
• -q, --quiet : Désactiver la sortie verbose (mode par défaut : verbose).
• -ua, --user-agent : Chaîne User-Agent personnalisée pour les requêtes.

Détails des risques pour chaque point d'accès trouvé par APIDetector

Exposer des points d'accès de documentation Swagger ou OpenAPI peut présenter divers risques, principalement liés à la divulgation d'informations. Voici une liste ordonnée basée sur les niveaux de risque potentiels, avec des points d'accès similaires regroupés pour le scan APIDetector :

1. Points d'accès à haut risque (Documentation API directe) :

• Points d'accès :
  • '/swagger-ui.html', '/swagger-ui/', '/swagger-ui/index.html', '/api/swagger-ui.html', '/documentation/swagger-ui.html', '/swagger/index.html', '/api/docs', '/docs', '/api/swagger-ui', '/documentation/swagger-ui'
• Risque :
  • Ces points d'accès servent généralement l'interface Swagger UI, qui fournit un aperçu complet de tous les points d'accès API, y compris les formats de requêtes, les paramètres de requête, et parfois même des exemples de requêtes et réponses.
  • Niveau de risque : Élevé. Exposer ces éléments donne aux attaquants potentiels des informations détaillées sur votre structure API et les vecteurs d'attaque possibles.

2. Points d'accès à risque moyen-élevé (Schéma/Spécification API) :

• Points d'accès :
  • '/openapi.json', '/swagger.json', '/api/swagger.json', '/swagger.yaml', '/swagger.yml', '/api/swagger.yaml', '/api/swagger.yml', '/api.json', '/api.yaml', '/api.yml', '/documentation/swagger.json', '/documentation/swagger.yaml', '/documentation/swagger.yml'
• Risque :
  • Ces points d'accès fournissent des fichiers de spécification Swagger/OpenAPI bruts. Ils contiennent des informations détaillées sur les points d'accès API, y compris les chemins, les paramètres et parfois les méthodes d'authentification.

3. Points d'accès à risque moyen (Versions de documentation API) :

• Points d'accès :
  • '/v2/api-docs', '/v3/api-docs', '/api/v2/swagger.json', '/api/v3/swagger.json', '/api/v1/documentation', '/api/v2/documentation', '/api/v3/documentation', '/api/v1/api-docs', '/api/v2/api-docs', '/api/v3/api-docs', '/swagger/v2/api-docs', '/swagger/v3/api-docs', '/swagger-ui.html/v2/api-docs', '/swagger-ui.html/v3/api-docs', ,

4. Points d'accès à risque plus faible (Configuration et ressources) :

• Points d'accès :
  • '/swagger-resources', '/swagger-resources/configuration/ui', '/swagger-resources/configuration/security', '/api/swagger-resources', '/api.html'
• Risque :
  • Ces points d'accès fournissent souvent des informations auxiliaires, des détails de configuration ou des ressources liées à la mise en place de la documentation API.
  • Niveau de risque : Plus faible. Ils peuvent ne pas révéler directement les détails des points d'accès API mais peuvent donner un aperçu de la configuration et de la mise en place de la documentation API.

Résumé :

• Risque le plus élevé : Exposer directement les interfaces de documentation API interactives.
• Risque moyen-élevé : Exposer les fichiers bruts de schéma/spécification API.
• Risque moyen : Documentation API spécifique à une version.
• Risque plus faible : Fichiers de configuration et de ressources pour la documentation API.

Recommandations :

• Contrôle d'accès : Assurez-vous que ces points d'accès ne sont pas accessibles publiquement ou sont au moins protégés par des mécanismes d'authentification.
• Exposition spécifique à l'environnement : Envisagez de n'exposer la documentation API détaillée que dans des environnements de développement ou de test, et non en production.
• Surveillance et journalisation : Surveillez l'accès à ces points d'accès et configurez des alertes pour les schémas d'accès inhabituels.

Contribuer

Les contributions à APIDetector sont les bienvenues ! N'hésitez pas à forker le dépôt, à apporter des modifications et à soumettre des pull requests. Un grand merci aux membres contributeurs qui ont aidé avec les tests et les suggestions de fonctionnalités :

• Filipi Pires (Ambassadeur) - https://www.linkedin.com/in/filipipires/
• Denis Lourenço - https://www.linkedin.com/in/🚲denis-lourenço-18b07a128/
• Bruno Francisco Cardoso - https://www.linkedin.com/in/bruno-francisco-cardoso-27445953/

Avis de non-responsabilité légal

L'outil APIDetector est strictement destiné à des fins de test et d'éducation uniquement. Les développeurs d'APIDetector déclinent toute responsabilité et ne sauraient être tenus responsables de toute utilisation abusive, conséquences imprévues ou dommages causés par l'utilisation de cet outil. Toute utilisation non autorisée, illégale ou autrement nuisible d'APIDetector est expressément interdite. L'utilisateur final assume l'entière responsabilité de se conformer à toutes les lois locales, étatiques, fédérales et internationales applicables. En utilisant cet outil, l'utilisateur reconnaît détenir les autorisations nécessaires pour tester les réseaux ou systèmes qu'il a l'intention de scanner et accepte d'indemniser les développeurs contre toute réclamation découlant de son utilisation. L'utilisateur final est seul responsable de s'assurer que son utilisation de cet outil ne viole aucune restriction légale ni condition d'utilisation des réseaux ou systèmes testés.

Avis de non-responsabilité : Utilisation de l'outil APIDetector L'outil APIDetector est conçu exclusivement pour des tests légitimes et des fins éducatives. Il est fourni "en l'état" sans garantie d'aucune sorte, expresse ou implicite. Les développeurs et distributeurs d'APIDetector déclinent expressément toute responsabilité pour une utilisation abusive, des conséquences imprévues ou des dommages résultant de l'utilisation de cet outil. Avis légal important : Toute utilisation non autorisée, illégale ou contraire à l'éthique d'APIDetector est strictement interdite. Les utilisateurs sont seuls responsables du respect de toutes les lois locales, étatiques, fédérales et internationales applicables, ainsi que de toute condition d'utilisation régissant les réseaux ou systèmes avec lesquels ils interagissent. En utilisant APIDetector, les utilisateurs confirment qu'ils possèdent les autorisations nécessaires pour tester les réseaux ou systèmes ciblés. Assomption de risque et indemnisation : En téléchargeant, installant ou utilisant APIDetector, l'utilisateur assume l'entière responsabilité de toute répercussion juridique associée à son utilisation. Les développeurs et distributeurs d'APIDetector ne sauraient être tenus responsables de toute conséquence juridique, dommage ou réclamation de tiers découlant de son utilisation. Les utilisateurs acceptent d'indemniser et de dégager de toute responsabilité les développeurs et distributeurs contre toute réclamation, frais juridiques ou responsabilités associés à leurs actions.

Licence

Ce projet est sous licence MIT License.

Remerciements

• Merci à tous les contributeurs qui ont aidé avec les tests, suggestions et améliorations.
• Auteur : Rafael B. Brinhosa - https://www.linkedin.com/in/brinhosa/