flawopen.com/Répertoire/Références

Guides de référence en sécurité

Utilisez ces références pour vérifier les hypothèses de sécurité concernant les frameworks, les ORM, l’authentification, les applications serverless et les agents IA. Chaque guide relie l’explication et la correction aux détails techniques.

• Claude Code MemoryTrap : mémoire d’agent — flawopen.com

  Divulgation MemoryTrap de Cisco : mémoire persistante de Claude Code, correctif v2.1.50 et contrôles pour les agents.

• Sandbox d’agents IA : conteneurs et microVMs

  Comparez les frontières d’isolation des conteneurs, de gVisor et des microVM pour les agents IA.

• Autoriser les outils des agents IA

  Réduisez l’agence excessive des agents IA avec des outils ciblés, une autorisation par utilisateur et le moindre privilège.

• Bots IA de revue de PR : prévenir SSRF — flawopen.com

  Comment le texte non fiable d’une pull request peut influencer les outils d’IA, et comment limiter les permissions du bot et l’accès réseau.

• Risques de sécurité de addJavascriptInterface sur Android

  WebView expose des méthodes natives à chaque frame. Comprenez le risque XSS de addJavascriptInterface et isolez les pages non fiables.

• Angular : XSS, valeurs sûres et API de bypass

  Angular échappe le texte et assainit HTML et URL. Voyez où bypassSecurityTrust* désactive la protection et comment auditer les sinks XSS.

• XSS par MIME sniffing : Content-Type et nosniff

  Découvrez comment le MIME sniffing peut transformer des fichiers envoyés en documents, le rôle de nosniff et les pratiques de téléchargement sûres.

• strncpy() est-elle plus sûre que strcpy() ?

  En C, strncpy() est moins risquée que strcpy(), mais ne garantit pas le caractère nul final. Découvrez pourquoi vérifier snprintf et strlcpy.

• CSP et échappement de sortie : faut-il les deux ?

  L’encodage de sortie prévient les XSS selon le contexte ; CSP limite certains impacts si une faille subsiste. Découvrez comment combiner les deux.

• Jeton CSRF pour GET : quand est-il nécessaire ?

  Un GET sûr ne change pas l’état. Découvrez quand protéger les méthodes non sûres contre CSRF et corriger les anciens GET à effet de bord.

• CWE vs CVE : quelle est la différence ?

  CWE vs CVE : quelle est la différence ? : le CWE est la catégorie — un type de bug, comme « injection SQL » (CWE-89). Le CVE est l'instance — une occurrence précise et documentée

• dangerouslySetInnerHTML est-il sûr dans React ?

  React échappe le texte JSX, mais dangerouslySetInnerHTML interprète le HTML. Vérifiez ce point XSS et affichez le texte enrichi en sécurité.

• Dependency Confusion : risques et défenses

  Comment une source de paquet ambiguë peut introduire une dépendance inattendue, et comment les règles de registre et la CI réduisent ce risque.

• Django ORM et SQL Injection : bonnes pratiques

  Les QuerySets Django paramètrent les valeurs. Découvrez les risques du SQL brut, des expressions dynamiques et les règles de vérification.

• Exposition du socket Docker : risques et défenses

  L’exposition du socket du démon Docker peut lui conférer une autorité étendue. Découvrez ses limites, les risques liés aux capacités et des paramètres plus sûrs.

• Injection SQL dans Doctrine ORM : requêtes sûres

  Liez les valeurs DQL et SQL avec des paramètres. Découvrez où QueryBuilder reste injectable et comment autoriser le tri dynamique.

• DOMPurify suffit-il pour sécuriser innerHTML ?

  DOMPurify protège le HTML riche au bon sink. Découvrez ses limites de contexte, le post-traitement, Trusted Types et les contrôles de production.

• .NET BinaryFormatter : risques et migration

  Microsoft indique que BinaryFormatter ne peut pas être sécurisé. Découvrez le risque, .NET 9 et les étapes de migration.

• XmlReader de .NET est-il sûr contre XXE ?

  XmlReader interdit les DTD par défaut. Découvrez le changement de .NET Framework 4.5.2 et la sécurisation du parsing XML.

• EF Core FromSqlRaw : SQL paramétré sûr

  Utilisez FromSqlRaw avec des paramètres séparés. Découvrez FromSqlInterpolated, les versions EF Core et le SQL dynamique sûr.

• Node.js exec() vs execFile() : différences et sécurité

  Comparez exec() et execFile() dans Node.js : shell, arguments, injection de commandes et choix de l’API.

• FastAPI et SQL Injection : limites de Pydantic

  FastAPI valide les données, mais la sécurité SQL dépend des requêtes. Découvrez les paramètres SQLAlchemy et les identifiants dynamiques sûrs.

• SSRF avec fetch() Node.js : récupérer des URL sans risque

  Le fetch serveur peut atteindre une destination choisie par l’utilisateur. Découvrez destinations fixes, redirections, DNS et filtrage réseau.

• SSTI FreeMarker et Velocity : sécuriser les modèles

  Contrôlez la source des modèles, limitez les objets Java exposés et isolez le rendu pour réduire le risque SSTI avec FreeMarker et Velocity.

• Injection de scripts GitHub Actions : entrées sûres

  Les valeurs GitHub peuvent devenir du code shell dans run. Protégez-les avec env, des permissions minimales et des contrôles pull_request_target.

• GORM Raw SQL : éviter l’injection SQL en Go

  Utilisez des paramètres liés avec GORM Raw. Découvrez pourquoi les valeurs sont protégées et pourquoi les identifiants SQL exigent une liste blanche.

• Échapper les guillemets suffit-il contre SQL Injection ?

  Non. Les requêtes paramétrées séparent les données du SQL ; l’échappement dépend du moteur et reste fragile. Utilisez une liste blanche pour les identifiants.

• Utiliser un ORM suffit-il à prévenir l'injection SQL ?

  Utiliser un ORM suffit-il à prévenir l'injection SQL ? : pour son API de requête standard, oui. Tout ORM courant fournit aussi une échappatoire vers du SQL brut, et celles-ci comportent

• XXE Java : DocumentBuilderFactory est-elle sûre par défaut ?

  Les parsers du JDK limitent certaines attaques, mais autorisent l’accès externe par défaut. Réglages sûrs et différences entre fournisseurs.

• Sécurité d’ObjectInputStream en Java : désérialisation sûre

  Des données Java non fiables peuvent déclencher des gadgets dans readObject(). Découvrez filtres, formats sûrs et flux hérités.

• Java Runtime.exec() et Command Injection : que change-t-il ?

  Runtime.exec(String) ne lance pas de shell, mais une entrée peut modifier les arguments. Utilisez ProcessBuilder et validez chaque valeur.

• ReDoS dans Node.js : regex et CVE-2026-83606

  Voyez comment le backtracking regex bloque Node.js, le cas CVE-2026-83606 et les correctifs.

• render_template_string() de Jinja2 est-il sûr ?

  Utilisez un modèle Jinja littéral et transmettez les données utilisateur via le contexte. SSTI, autoescape et CVE-2024-56201 expliqués.

• JSON.parse() provoque-t-il une pollution de prototype ?

  JSON.parse() ne pollue pas les prototypes. Découvrez comment les fusions et clés non sûres créent le risque.

• JSON.parse() est-il plus sûr que eval() ?

  Pourquoi JSON.parse() traite l’entrée comme des données, comment eval() peut l’exécuter et le rôle du callback reviver.

• JWT dans localStorage ou cookies HttpOnly : lequel est plus sûr ? — flawopen.com

  Comparaison architecturale entre JWT dans localStorage et cookies HttpOnly SameSite : vol de jeton par XSS, compromis liés au CSRF et architectures d'authentification recommandées.

• Knex.js protège-t-il contre les injections SQL ?

  Knex lie les valeurs. Utilisez les bindings de knex.raw() et une liste autorisée pour les identifiants dynamiques.

• lodash.merge() : risque de pollution de prototypes ?

  Les correctifs Lodash varient selon la fonction et la version. Vérifiez les plages concernées, la version corrigée et la validation des données.

• Markdown protège-t-il contre les XSS ?

  Markdown ne sécurise pas automatiquement le HTML. Découvrez quand le HTML brut est transmis et comment assainir le résultat.

• Mass assignment : risques et listes de champs autorisés

  Le mass assignment permet à une requête de modifier des champs que l’utilisateur ne devrait pas contrôler. Listes et autorisation.

• Sécurité MCP : périmètre des outils | FlawOpen

  Comprenez les frontières de confiance MCP et limitez les outils locaux, leurs permissions et le consentement pour prévenir l’exposition de données.

• MyBatis ${} et #{} : prévenir la SQL Injection

  Dans MyBatis, #{} lie les valeurs via JDBC et ${} insère du texte SQL brut. Binding sûr et liste autorisée pour les identifiants.

• MySQLi vs PDO : prepared statements sûres

  MySQLi et PDO peuvent prévenir la SQL Injection avec des prepared statements. Comparez le binding, les drivers et les pratiques sûres.

• Newtonsoft.Json TypeNameHandling : configuration sûre ?

  Json.NET lit les noms CLR de $type. Gardez TypeNameHandling à None pour le JSON non fiable ; sinon, validez les types avec un binder strict.

• Next.js Server Actions CSRF : Origin et configuration sûre

  Comprendre la vérification Origin, les risques liés au proxy et à allowedOrigins, et l’autorisation de chaque action.

• Fuite d’état serverless : isoler les données par requête

  Comment la réutilisation des runtimes serverless peut exposer des données périmées, et isoler identité et état par requête.

• NHibernate protège-t-il contre les injections SQL ?

  Les paramètres HQL de NHibernate séparent valeurs et syntaxe. Découvrez les risques de concaténation et d’identifiants dynamiques.

• Risque de command injection avec Node.js exec()

  Node.js exec() lance un shell. Découvrez le risque de command injection et comment execFile() avec validation évite l’analyse du shell.

• Qu'est-ce qu'une requête paramétrée ?

  Qu'est-ce qu'une requête paramétrée ? : une requête paramétrée revient à remplir un formulaire à champs étiquetés plutôt qu'à écrire toute une lettre à la main. La base de données reç

• Prisma $queryRaw protège-t-il contre les injections SQL ?

  Prisma paramètre les valeurs des tagged templates. Découvrez quand les requêtes raw sont sûres et pourquoi les identifiants SQL exigent une allowlist.

• L’interpolation dans where() de Rails est-elle sûre ?

  Interpoler des données de requête dans where() peut provoquer une SQL Injection. Utilisez des paramètres liés ou un hash.

• Sécurité des agents IA : outils et isolation

  Sécurisez les outils d’agents IA : droits par utilisateur, validation des actions sensibles et exécution isolée. Limites du sandbox et du réseau.

• Sequelize query() protège-t-il contre les injections SQL ?

  Les requêtes raw Sequelize nécessitent des paramètres séparés. Découvrez les différences entre replacements, bind et identifiants SQL.

• SQLAlchemy text() protège-t-il contre les injections SQL ?

  SQLAlchemy text() accepte du SQL brut ; liez les valeurs dans execute(). Découvrez les risques liés à l’interpolation et aux identifiants dynamiques.

• SSRF et métadonnées cloud : risques et défenses

  Comment une SSRF atteint les métadonnées cloud ; contrôles du fournisseur, moindre privilège et filtrage sortant réduisent le risque.

• Svelte protège-t-il du XSS par défaut ?

  Svelte échappe les expressions de texte ordinaires. Découvrez pourquoi {@html} exige du HTML fiable ou assaini et comment repérer son usage.

• TypeORM QueryBuilder protège-t-il des injections SQL ?

  TypeORM lie les paramètres QueryBuilder. Conditions interpolées, SQL brut et identifiants dynamiques exigent toutefois une revue.

• Risque XSS de Vue v-html

  Vue échappe le texte {{ }} par défaut, mais v-html rend du HTML brut. Découvrez le risque XSS, la gestion du texte riche et l’audit des fichiers .vue.

• Cosign GHSA-fx35-mq7g-6g98 : Bundle contourné

  Défaut des bundles JSON hérités, versions Cosign corrigées et contrôles CI pour vérifier les blobs.

• Injection NoSQL MongoDB : filtres sûrs

  Découvrez comment un objet JSON non validé modifie un filtre MongoDB, comment valider les types et tester le correctif.

• Un ID numérique peut-il aussi provoquer une injection SQL ?

  Même un ID numérique devient risqué s’il est inséré dans la requête par formatage de chaîne. Comprenez le problème et utilisez des paramètres.

• Object.assign() et Prototype Pollution : que risque-t-on ?

  Object.assign() peut modifier le prototype cible via __proto__. Découvrez la différence avec spread et sécurisez les fusions profondes.

• Node.js path.join() ne bloque pas Path Traversal

  path.join() normalise les chemins mais autorise .. ; résolvez et vérifiez la contenance, puis traitez les liens symboliques.

• PHP include() et chemins contrôlés par l’utilisateur

  Quand include() expose des fichiers ou exécute du code, pourquoi le RFI dépend de la configuration et comment utiliser une liste autorisée.

• PHP == et les comparaisons de magic hash

  PHP 8 compare deux chaînes numériques par valeur : les hashes 0e peuvent coïncider. Validez les types et utilisez hash_equals() pour les secrets.

• PHP unserialize() et les données non fiables

  PHP déconseille unserialize() sur des données non fiables. Préférez JSON ; authentifiez les données sérialisées avant analyse.

• Corriger le path traversal avec Python os.path.join()

  Comprenez les chemins absolus et .. dans os.path.join() ; résolvez le chemin et vérifiez son confinement avec commonpath().

• Python pickle.load() : risques des données non fiables

  Le pickle Python peut exécuter du code au chargement. Comprenez CWE-502 et remplacez les entrées non fiables par du JSON validé.

• Sécurité XXE XML en Python : ElementTree, Expat et lxml

  ElementTree évite-t-il XXE ? Risques Expat par version, options lxml et traitement sûr du XML non fiable.

• Qu’est-ce que ReDoS (retour arrière catastrophique) ?

  Comment les regex ambiguës provoquent un déni de service et comment borner les correspondances.

• Ruby YAML.load est-il sûr ? Versions de Psych et safe_load

  Vérifiez la version de Psych, utilisez safe_load et ne désérialisez jamais un YAML ou Marshal non fiable avec une API non sécurisée.

• Rust : le bloc unsafe est-il sûr ?

  Comprendre unsafe, la soundness et la correction apportée après CVE-2021-25900.

• SameSite=Strict remplace-t-il les jetons CSRF ?

  Découvrez ce que protègent SameSite=Strict et Lax, leurs limites entre sous-domaines et quand les associer à des jetons CSRF.

• La vérification des requêtes sqlx à la compilation empêche-t-elle les injections SQL ?

  Découvrez ce que vérifie query!, comment les paramètres liés préviennent l’injection SQL et quand query().bind() est sûr.

• Qu’est-ce que l’injection de template côté serveur ?

  Comprendre SSTI, ses impacts selon le moteur et les moyens de séparer les modèles des données non fiables.

• Les procédures stockées empêchent-elles l’injection SQL ?

  Une procédure stockée n’empêche l’injection SQL que si elle lie les paramètres ; découvrez comment sécuriser le SQL dynamique.

• Un téléversement SVG présente-t-il un risque XSS ?

  Découvrez quand les scripts SVG s’exécutent et comment assainir, pixelliser et isoler les fichiers envoyés.

• WKWebView : HTML non fiable, sûr ?

  WKWebView affiche le HTML reçu, scripts compris. Découvrez quand assainir le contenu et protéger le pont natif.

• XSS réfléchi, stocké et DOM : quelles différences ?

  Comparez les chemins du XSS réfléchi, stocké et DOM, puis corrigez chaque faille au point de rendu.

• Qu’est-ce qu’une vulnérabilité Zip Slip ?

  Découvrez comment des noms de fichiers ZIP manipulés peuvent sortir du dossier d’extraction et comment valider chaque chemin.