Détection de Vulnérabilités

Analysez le code où les entrées contrôlées par l'utilisateur sont utilisées pour construire des requêtes de base de données. Recherchez la concaténation d'entrées non assainies ou les méthodes ORM susceptibles d'injection. Sur mobile/ordinateur de bureau, vérifiez l'utilisation de bases de données locales/SQLite.

Analysez le code où les entrées contrôlées par l'utilisateur sont utilisées pour construire des requêtes dans des bases de données NoSQL (MongoDB, etc.). Recherchez l'utilisation non sécurisée d'opérateurs ($where, etc.) ou la construction d'objets de requête avec des données non assainies. Typiquement une vulnérabilité backend.

Analysez le code où des entrées contrôlées par l'utilisateur pourraient être passées à des commandes système (par ex. exec, system, popen). Recherchez les entrées non assainies utilisées dans les chaînes de commande. Vérifiez les interactions avec le code natif sur mobile/ordinateur de bureau ou les bibliothèques du système d'exploitation.

Analysez le code où les entrées contrôlées par l'utilisateur sont évaluées ou exécutées directement (par ex. eval, exec, moteurs de script) sans validation ni sandboxing appropriés. Vérifiez les WebViews, le chargement dynamique de code ou les scripts intégrés sur mobile/ordinateur de bureau/bibliothèques.

Analysez le code où des objets sérialisés provenant de sources non fiables (entrée utilisateur, fichiers, réseau) sont désérialisés sans validation appropriée, ce qui peut potentiellement conduire à une exécution de code à distance (par ex. pickle, sérialisation Java/PHP). Peut se produire côté client/serveur.

Analysez le code où les entrées contrôlées par l'utilisateur (URL, noms d'hôte, chemins) sont utilisées pour effectuer des requêtes HTTP côté serveur vers des ressources internes ou externes sans validation appropriée. Vérifiez si les applications mobiles/de bureau effectuent des requêtes basées sur des entrées externes.

Analysez le code où les entrées contrôlées par l'utilisateur sont directement intégrées dans des modèles côté serveur sans assainissement approprié, permettant potentiellement l'exécution de code au sein du moteur de modèles.

Analysez le code ou les configurations de serveur où des entrées contrôlées par l'utilisateur pourraient être incluses dans des fichiers traités par le serveur web pour des directives SSI, permettant potentiellement l'inclusion de fichiers ou l'exécution de commandes si l'exécution SSI est activée.

Scannez le code à la recherche de clés API, de mots de passe, de clés privées, de chaînes de connexion à la base de données, d'identifiants par défaut ou d'autres secrets sensibles codés en dur.

Analysez le code où les entrées contrôlées par l'utilisateur sont utilisées dans les chemins de fichiers (lecture, écriture, inclusion de fichiers) sans assainissement approprié, permettant potentiellement l'accès à des fichiers restreints (LFI/RFI sur le serveur, accès aux fichiers locaux sur mobile/ordinateur de bureau/bibliothèques).

Analysez le code côté client (JavaScript) où les entrées contrôlées par l'utilisateur (par ex. fragments d'URL, paramètres, postMessage) sont utilisées pour construire des URL ou des chemins pour les requêtes API ou la navigation, pouvant potentiellement conduire à un accès non intentionnel à des ressources ou à des redirections. Pertinent pour les WebViews/frameworks JS sur mobile/ordinateur de bureau.

Analysez le code qui analyse les entrées XML (locales ou récupérées). Vérifiez si le traitement des entités externes est désactivé et si les entrées de l'utilisateur peuvent influencer la structure XML et conduire à une XXE.

Analysez le code qui gère les téléchargements de fichiers (vérifications côté client, validation côté serveur). Vérifiez la validation des types de fichiers, des noms, des tailles et des emplacements de stockage pour empêcher l'exécution des fichiers téléchargés ou la traversée de répertoire.

Analysez le code à la recherche de points de terminaison sensibles ou de fonctions sans contrôle d'authentification (par ex. décorateurs, middleware manquants). Vérifiez les flux de connexion, la manipulation des paramètres ou les contournements d'authentification locale sur mobile/ordinateur de bureau.

Analysez les politiques de mot de passe, la fin de session, les processus de suppression de compte et les mécanismes de récupération pour déceler les failles de sécurité. Inclut la gestion des identifiants locaux sur ordinateur de bureau/mobile.

Analysez le code pour vérifier que les contrôles d'autorisation (rôles, permissions) sont correctement appliqués côté serveur après l'authentification. Recherchez les failles logiques permettant un accès non autorisé à des fonctions ou des données. Vérifiez la logique d'autorisation locale sur ordinateur de bureau/mobile, le cas échéant.

Analysez le code à la recherche de fonctions permettant des modifications non sécurisées des rôles/permissions ou l'invocation de fonctions d'administration par des utilisateurs ayant des privilèges inférieurs. Vérifiez la gestion des privilèges locaux sur ordinateur de bureau/mobile/bibliothèques du système d'exploitation.

Dans les applications multi-locataires (c'est-à-dire si le système prend en charge des locataires/organisations), analysez le code pour vous assurer que toutes les requêtes de données et opérations sont strictement filtrées par l'ID de locataire de l'utilisateur authentifié. Si l'application n'est pas multi-locataire, cet élément peut ne pas être pertinent.

Analysez le code où des identifiants contrôlés par l'utilisateur (ID dans les URL, paramètres) sont utilisés pour accéder à des ressources sans vérifier l'autorisation de l'utilisateur pour cette ressource spécifique. Vérifiez comment les applications de bureau/mobiles construisent les requêtes.

Analysez des fonctions telles que l'inscription, la modification de profil, la réinitialisation de mot de passe, etc., à la recherche de failles logiques permettant la prise de contrôle de compte (jetons prévisibles, manque de vérification, etc.). Inclut la gestion locale des identifiants/jetons sur ordinateur de bureau/mobile.

Analysez la logique de génération, de vérification et de gestion des codes OTP/MFA pour les vulnérabilités de contournement (limitation de débit, prévisibilité, saut d'étapes). Vérifiez la gestion côté client sur ordinateur de bureau/mobile.

Analysez l'utilisation de JWT : vérification de la signature (alg 'none', clés faibles), validation des revendications (exp, iss, aud), stockage non sécurisé (par ex. localStorage, stockage mobile/de bureau non sécurisé).

Si SAML est utilisé, analysez le code de traitement : validation de la signature, XXE dans l'analyse, logique ACS, validation de condition/audience.

Analysez les flux OAuth/OIDC : validation du paramètre 'state' (CSRF), gestion non sécurisée du code, problèmes de flux implicite, validation de l'URI de redirection. Vérifiez l'implémentation côté client sur mobile/web/ordinateur de bureau.

Analysez les applications multi-locataires avec des IDP configurables par le locataire (SAML/OIDC) : sécurité de la configuration (SSRF, redirections), analyse (XXE), traitement des assertions (contournement de signature, injection de revendications), provisionnement, risques d'ATO du locataire.

Analysez le code à la recherche de séquences 'vérifier-puis-agir' sans verrouillage, d'opérations non atomiques, de manque de contraintes de base de données, pouvant conduire à des états incohérents ou à des contournements. Peut se produire côté client/serveur.

Analysez le code où l'entrée de l'utilisateur est reflétée dans HTML/JS sans encodage contextuel approprié (reflété, stocké). Vérifiez les WebViews, les navigateurs intégrés ou le rendu HTML dynamique sur mobile/ordinateur de bureau.

Analysez le JS côté client où les entrées de sources (URL, postMessage) affluent vers des puits (eval, innerHTML, location) sans assainissement (DOM-XSS, Redirection Ouverte). Pertinent pour les WebViews/frameworks JS sur mobile/ordinateur de bureau.

Analysez le code où l'entrée de l'utilisateur est insérée dans les en-têtes HTTP sans assainir CR (\r) et LF (\n), permettant l'injection d'en-tête ou la division de la réponse.

Analysez comment l'application traite et fait confiance aux en-têtes HTTP entrants tels que Host, X-Forwarded-For, X-Forwarded-Host et autres en-têtes contrôlables par le client. Recherchez les vulnérabilités où la manipulation de ces en-têtes peut conduire à contourner les contrôles de sécurité (par ex. restrictions basées sur l'IP), à l'empoisonnement du cache web, au SSRF, à une logique d'application incorrecte ou à d'autres comportements imprévus. Assurez-vous que les en-têtes sont correctement validés avant d'être utilisés dans des contextes sensibles à la sécurité.

Analysez le code où l'entrée de l'utilisateur détermine les cibles de redirection sans validation par rapport à une liste blanche. Vérifiez les WebViews/gestionnaires de schémas personnalisés/navigateurs intégrés sur mobile/ordinateur de bureau.

Analysez le code pour l'exposition de données sensibles : détails du serveur (erreurs, journaux, commentaires), informations utilisateur (réponses verbeuses, exposition de PII, journalisation non sécurisée). Recherchez en particulier les API ou les structures de données qui renvoient plus de données que nécessaire pour la fonctionnalité, comme l'exposition d'objets/modèles utilisateur entiers (y compris des champs sensibles comme les clés API, les indicateurs internes ou les PII inutiles) alors que seul un sous-ensemble d'informations est requis. Vérifiez le stockage local/journaux/configurations sur mobile/ordinateur de bureau.

Scannez le code à la recherche d'algorithmes faibles (MD5, SHA1, DES), de modes non sécurisés (ECB), de comparaisons en temps non constant, d'aléa non sécurisé, de manque de chiffrement/hachage approprié pour les données sensibles.

Analysez les requêtes qui modifient l'état : vérifiez l'implémentation/validation du jeton anti-CSRF, les cookies SameSite, les en-têtes standard. Envisagez le CSRF via les liens profonds mobiles ou les WebViews.

Analysez le code et les fichiers de configuration (par ex. Nginx, configurations cloud, Dockerfiles, IaC) pour les mauvaises configurations de sécurité telles que les modes de débogage, les identifiants par défaut, les en-têtes/cookies non sécurisés, les CORS permissifs, les erreurs verbeuses ou les permissions incorrectes. Examinez également les manifestes des applications mobiles/de bureau, les paramètres de construction et les configurations d'application locales.

Analysez le code où l'entrée de l'utilisateur construit des requêtes LDAP sans assainissement. Typiquement une vulnérabilité backend.

Analysez le code générant des fichiers téléchargeables/exportables (CSV, XLSX) en utilisant l'entrée de l'utilisateur. Vérifiez l'assainissement/l'échappement des entrées commençant par (=, +, -, @, ＝).

Analysez le code générant des documents (PDF, DOCX) à l'aide de bibliothèques. Recherchez une utilisation non sécurisée des entrées menant à XSS, SSRF, injection de commandes ou exploits de bibliothèques. Peut se produire côté client/serveur.

Analysez le code (en particulier C/C++, natif mobile/ordinateur de bureau/bibliothèques) pour les opérations arithmétiques sur des nombres contrôlés par l'utilisateur sans vérification des limites, pouvant potentiellement conduire à des contournements ou à un comportement inattendu.

(JavaScript/Node.js) Analysez le code pour les motifs (fusion récursive, définition de propriété par chemin) où l'entrée de l'utilisateur peut modifier les prototypes d'objets globaux (contournement potentiel, DoS, RCE). Pertinent pour les WebViews/frameworks JS sur mobile/ordinateur de bureau.

Analysez le code du gestionnaire WebSocket : validation des entrées, contrôles d'autorisation (authz), XSS dans les messages. Vérifiez le détournement de WebSocket intersites (CSWSH) via des contrôles d'origine faibles. Vérifiez la gestion côté client sur ordinateur de bureau/mobile.

Examinez les fichiers de configuration de l'application et du serveur ainsi que le code associé pour les paramètres de cache non sécurisés. Cela inclut une utilisation incorrecte de l'en-tête Vary, des paramètres de cache de framework mal configurés ou des en-têtes de contrôle de cache explicites incorrects qui pourraient entraîner la mise en cache incorrecte de données sensibles, l'empoisonnement du cache ou la tromperie du cache basée sur la configuration elle-même.

Analysez le code pour les motifs de DoS : ReDoS, opérations coûteuses basées sur des entrées sans limites, épuisement des ressources (bombes zip), attaques de complexité algorithmique. Vérifiez la gestion des ressources locales sur ordinateur de bureau/mobile/bibliothèques.

Analysez le code où les frameworks lient l'entrée de l'utilisateur à des objets/modèles. Vérifiez si le filtrage empêche la définition de propriétés internes/sensibles à la sécurité.

Analysez le code où le type, le format, la longueur ou la plage de l'entrée ne sont pas validés avant d'être utilisés dans la logique, ce qui peut potentiellement altérer le flux de contrôle, contourner des règles ou provoquer des états incohérents.

Analysez le code de paiement/panier/tarification. Recherchez les contournements de la manipulation des prix côté client, la validation non sécurisée des articles/quantités, les problèmes de devise/arrondi, l'abus de remises/coupons et les conditions de course pendant le processus d'achat initial (par ex. utilisation de crédits plusieurs fois).

Analysez la logique pour les webhooks de paiement tiers (par ex. Stripe, PayPal) et la gestion du cycle de vie des abonnements. Vérifiez la validation de la signature du webhook. Assurez-vous que tous les événements pertinents sont gérés pour mettre à jour correctement le statut de l'utilisateur/service (par ex. charge.refunded, customer.subscription.deleted, invoice.payment_failed). Recherchez les conditions de course dans les mises à jour de statut et la validation non sécurisée du statut de paiement.

Analysez le code (en particulier C/C++, natif mobile/ordinateur de bureau/bibliothèques) pour les fonctions qui gèrent les entrées de l'utilisateur (strcpy, gets, memcpy) sans vérification des limites (corruption de la mémoire, exécution de code).

Analysez le code (en particulier C/C++, natif mobile/ordinateur de bureau/bibliothèques) pour les pointeurs utilisés après la libération de la mémoire (plantages, corruption de données, exécution de code).

Analysez le code (en particulier C/C++, natif mobile/ordinateur de bureau/bibliothèques) pour les tentatives de libérer deux fois la même région de mémoire (corruption de la mémoire, exploitation).

Analysez le code (en particulier C/C++, natif mobile/ordinateur de bureau/bibliothèques) où l'entrée de l'utilisateur est utilisée directement comme argument de chaîne de formatage (printf, sprintf), permettant la lecture/écriture en mémoire.

Analysez le code des applications mobiles pour le stockage de données sensibles (identifiants, PII, jetons) dans des emplacements non sécurisés (par ex. SharedPreferences sans chiffrement, stockage externe, journaux, bases de données non sécurisées) accessibles à d'autres applications ou utilisateurs ayant un accès physique.

Analysez le code des applications mobiles pour la présence et l'efficacité des mécanismes de détection de root/jailbreak, d'anti-débogage et de détection d'émulateur. Vérifiez si ces contrôles peuvent être facilement contournés (par ex. uniquement des contrôles côté client, logique prévisible).

Analysez le code des applications mobiles qui gèrent les schémas d'URL personnalisés (liens profonds). Recherchez le manque de validation des entrées sur les paramètres (potentiel de XSS, Traversée de Répertoire, SQLi si transmis au backend), les risques de CSRF (si des actions sont déclenchées sans intention de l'utilisateur) ou les Redirections Ouvertes.

Analysez le code des applications mobiles utilisant des WebViews. Vérifiez si l'exécution de JavaScript est activée (setJavaScriptEnabled(true)), si le pont JavaScript (addJavascriptInterface) expose des fonctions natives sensibles, et si le contenu chargé est correctement validé (potentiel de XSS, chargement de contenu non fiable).

Analysez la configuration réseau et le code des applications mobiles. Vérifiez la désactivation de l'App Transport Security (ATS) sur iOS, le trafic en clair autorisé sur Android, l'absence d'épinglage de certificat ou les configurations TLS/SSL non sécurisées.

Analysez le code des applications mobiles qui lit/traite des fichiers provenant du stockage externe ou d'emplacements accessibles par d'autres applications. Recherchez la Traversée de Répertoire, le manque de validation du contenu des fichiers ou une gestion non sécurisée qui pourrait conduire à l'exécution de code ou à une fuite de données si une application malveillante modifie le fichier.

Analysez le code des applications mobiles utilisant des mécanismes IPC (par ex. Intents, Content Providers, Broadcast Receivers sur Android ; XPC sur iOS). Recherchez les composants mal protégés (permissions manquantes, filtres d'intent trop larges), les fuites de données ou la capacité des applications malveillantes à envoyer des messages conçus pour déclencher des actions non intentionnelles.

Analysez le code des applications mobiles qui implémentent l'authentification biométrique. Vérifiez si le résultat de l'authentification est validé côté serveur ou si un contournement côté client est possible. Assurez-vous que les mécanismes de secours sont sécurisés.

Analysez le code des contrats intelligents pour les vulnérabilités de réentrance, où des appels externes peuvent ré-entrer dans le contrat appelant avant la fin de l'exécution initiale, entraînant potentiellement des incohérences d'état ou le drainage de fonds. Recherchez des motifs comme 'appel-après-changement-d'état' au lieu de 'vérifier-effets-interactions'.

Analysez le code des contrats intelligents pour les vulnérabilités de dépassement ou de sous-dépassement d'entier dans les opérations arithmétiques, en particulier celles impliquant des soldes de jetons ou des calculs critiques. Assurez-vous d'utiliser des bibliothèques mathématiques sécurisées.

Analysez la logique des contrats intelligents qui repose sur block.timestamp ou block.number pour des opérations critiques (par ex. déverrouillage de fonds, détermination des gagnants). Ceux-ci peuvent être manipulés dans une certaine mesure par les mineurs.

Analysez les contrats intelligents pour les fonctions ou les boucles qui pourraient consommer une quantité illimitée de gaz, entraînant un déni de service pour les utilisateurs ou le contrat lui-même. Recherchez des motifs comme l'itération sur de grands tableaux ou des calculs complexes qui peuvent dépasser les limites de gaz des blocs.

Analysez la logique des contrats intelligents pour les vulnérabilités où le résultat d'une transaction peut être influencé par l'ordre dans lequel les transactions sont minées. Recherchez des scénarios où un attaquant peut observer une transaction et soumettre la sienne pour exploiter le système (par ex. échanges décentralisés, enchères).

Analysez les contrats intelligents qui dépendent de sources de données externes (oracles). Vérifiez comment les données sont récupérées, validées et utilisées. Recherchez les vulnérabilités où l'oracle peut être manipulé ou ses données peuvent être influencées pour exploiter le contrat.

Analysez le code des contrats intelligents utilisant delegatecall. Assurez-vous que la disposition de stockage du contrat cible est compatible et que delegatecall n'est pas utilisé avec des contrats non fiables, ce qui pourrait entraîner une corruption du stockage ou une exécution de code arbitraire dans le contexte du contrat appelant.

Analysez les fonctions des contrats intelligents pour des mécanismes de contrôle d'accès appropriés (par ex. onlyOwner, require(msg.sender == authorized_address)). Recherchez les fonctions sensibles qui peuvent être appelées par des utilisateurs non autorisés.

Effectuez une revue générale de la logique métier du contrat intelligent pour identifier les failles, les cas limites ou les comportements non intentionnels qui pourraient être exploités. Cela nécessite de comprendre l'objectif prévu du contrat.

Analysez les contrats intelligents qui nécessitent de l'aléa. L'utilisation de sources sur la chaîne comme blockhash ou block.timestamp pour l'aléa peut être prévisible ou influencée par les mineurs. Vérifiez la dépendance à de telles sources pour les décisions de sécurité critiques.

Analysez les configurations de serveur, de proxy et de passerelle d'application (par ex. Nginx, Apache, HAProxy, CloudFront, configurations de passerelle API, IaC comme Terraform/CloudFormation) pour les paramètres qui pourraient permettre le HTTP Request Smuggling. Recherchez les configurations qui conduisent à une analyse ambiguë des requêtes entre les systèmes frontend et backend, telles qu'une mauvaise gestion des en-têtes Content-Length et Transfer-Encoding, ou un traitement incorrect de l'encodage par morceaux. Cela peut permettre aux attaquants de préfixer ou d'ajouter des données aux requêtes d'autres utilisateurs.

Analysez le code pour l'inclusion de scripts intersites (XSSi) et les fuites intersites (XS-Leaks). Recherchez les données sensibles (JSON, CSV, images) renvoyées sans isolation appropriée (par ex. absence d'en-têtes X-Content-Type-Options: nosniff, COOP/COEP) ou accessibles via des balises de script/frames provenant d'autres origines. Vérifiez les canaux latéraux (timing, événements d'erreur) qui pourraient divulguer des informations entre les origines.

Analysez l'Infrastructure as Code (IaC) ou les fichiers de configuration pour les paramètres de stockage cloud non sécurisés (par ex. buckets S3, Azure Blobs). Recherchez l'accès public, l'absence de chiffrement, l'absence de journalisation/versionnage ou les politiques de bucket trop permissives.

Analysez l'IaC et les configurations cloud pour les politiques de gestion des identités et des accès (IAM) trop permissives. Recherchez l'utilisation de caractères génériques (*), le non-respect du principe de moindre privilège, les identifiants IAM codés en dur ou les politiques de confiance d'emprunt d'identité non sécurisées.

Analysez les Dockerfiles et les manifestes Kubernetes. Recherchez l'exécution en tant que root, les directives utilisateur manquantes, l'utilisation de tags 'latest', les montages sensibles, le mode privilégié ou l'absence de limites de ressources.

Analysez Terraform, CloudFormation ou d'autres fichiers IaC pour les meilleures pratiques de sécurité. Recherchez les ressources non chiffrées, les groupes de sécurité ouverts (0.0.0.0/0), l'absence de sauvegardes ou les paramètres par défaut non sécurisés.

Analysez le code pour identifier si l'application utilise différents analyseurs pour le même format de données (par ex. JSON, YAML, XML) entre différents composants (par ex. frontend vs backend, proxy vs application). Les divergences d'analyse peuvent être exploitées pour contourner les contrôles de sécurité, conduisant à des vulnérabilités telles que le contournement de l'authentification, le XSS ou l'injection SQL. Par exemple, un proxy peut voir un ensemble de paramètres tandis que l'application backend en voit un autre.

Vérifiez si l'introspection est activée pour le point de terminaison GraphQL dans les environnements de production. L'introspection permet aux attaquants d'interroger le schéma complet, révélant toutes les requêtes, mutations, abonnements, types et champs disponibles. Cette fuite d'informations aide considérablement les attaquants à comprendre l'API et à découvrir des vulnérabilités potentielles.

Enquêtez si le point de terminaison GraphQL autorise le batching de requêtes, où plusieurs requêtes peuvent être envoyées dans une seule requête HTTP. Si cela n'est pas correctement restreint, les attaquants peuvent abuser de cette fonctionnalité pour exécuter un grand nombre de requêtes complexes simultanément, submergeant le serveur et provoquant une attaque par déni de service (DoS).

Analysez le code de paiement/panier/tarification : contournements de la manipulation des prix côté client, validation non sécurisée du statut de paiement, conditions de course (remises/crédits), problèmes de devise/arrondi, validation de quantité/article.

Analysez les fichiers de test (unitaires, intégration, e2e) pour comprendre la logique métier, les cas limites et les failles de sécurité potentielles. Recherchez les tests de sécurité commentés, les tests pour les bogues connus ou les données de test qui révèlent une logique sensible.

Analysez le code interagissant avec les grands modèles de langage (LLM). Recherchez les vulnérabilités d'injection de prompt, la gestion non sécurisée des sorties LLM (XSS via LLM) ou la fuite de contexte sensible dans les prompts.

Examinez la documentation du projet et les commentaires du code. Les divergences entre la documentation et l'implémentation révèlent souvent des bogues ou des problèmes de sécurité. Les commentaires peuvent contenir des TODO, des avertissements ou des explications de logique complexe suggérant des vulnérabilités.