Vérifiez et purifiez toutes les entrées, utilisez la vérification de la liste blanche et l'encodeur Java OWASP pour empêcher XSS; 2. Empêcher les attaques d'injection, utiliser les requêtes paramétrées pour éviter l'injection SQL et n'exécuter pas directement les commandes système entrées par les utilisateurs; 3. Gérer correctement l'authentification et la gestion des sessions, utilisez des algorithmes de hachage solides tels que BCrypt et stocker en toute sécurité les jetons de session; 4. Protéger les données sensibles, utiliser AES-256 pour crypter les données au repos, ne pas coder les touches dans le code et effacer rapidement des informations sensibles en mémoire; 5. évitez la désérialisation dangereuse et donnez la priorité à l'utilisation de formats de données sécurisés tels que JSON; 6. Assurer la sécurité des dépendances, mettre à jour et analyser régulièrement les vulnérabilités de la bibliothèque tierce; 7. Implémentez la gestion et la journalisation des erreurs sécurisées et n'exposez pas les détails internes aux utilisateurs; 8. Suivez le principe des autorisations minimales et configurez en toute sécurité JVM et Frameworks. En bref, les entrées externes doivent être vérifiées, purifiées et ne peuvent pas être exécutées aveuglément pour créer des applications Java défensives.

L'écriture du code Java sécurisé ne concerne pas les astuces magiques - il s'agit d'être conscient des pièges communs et du codage avec la défense à l'esprit. Même les développeurs expérimentés peuvent introduire des vulnérabilités en négligeant la validation des entrées, en abusant des API ou en assumant la confiance en cas de non-ne pas. Vous trouverez ci-dessous des pratiques clés pour éviter les défauts de sécurité les plus courants dans les applications Java.

1. Valider et désinfecter toutes les entrées

La contribution non fiable est à l'origine de nombreux problèmes de sécurité, notamment des attaques d'injection et des vulnérabilités de déni de service.

• Ne faites jamais confiance à la saisie des utilisateurs , que ce soit à partir de formulaires Web, d'API, de fichiers ou d'arguments en ligne de commande.
• Utilisez la validation de la liste blanche (permettez les bons modèles connus) au lieu des approches de liste noire.
• Pour les applications Web, désinfectez les entrées pour éviter les scripts croisés (XSS) . Utilisez des bibliothèques comme OWASP Java Encoder lors de la sortie des données sur HTML, JavaScript ou CSS.
• Valider la longueur, le type, le format et la plage. Par exemple:

   if (username == null ||! username.matches ("^ [a-za-z0-9 _] {3,20} $")) {
      lancer un nouveau IllégalArgumentException ("nom d'utilisateur invalide");
  }

Astuce: utilisez des frameworks comme le ressort avec des annotations de validation intégrées ( @NotBlank , @Pattern ) pour appliquer t?t les contraintes.

2. Empêcher les attaques d'injection (SQL, OS, etc.)

L'injection SQL reste un risque supérieur lorsque les requêtes dynamiques sont construites par concaténation des cordes.

? Utiliser des requêtes paramétrées ou des instructions préparées :

 String Query = "SELECT * FROM Users Where Email =?";
essayez (préparéStatement stmt = connection.preparestatement (requête)) {
    STMT.SETSTRING (1, Usemail);
    ResultSet rs = stmt.ExecuteQuery ();
}

? évitez:

 // Dangereux!
String Query = "SELECT * FROM Users Where Email = '" Usemail "'";

Pour l'injection de commande OS , ne transmettez jamais l'entrée de l'utilisateur directement à Runtime.exec() ou ProcessBuilder . S'il est inévitable, validez strictement et utilisez des commandes à liste blanche.

Envisagez d'utiliser des API ou des bibliothèques plus s?res qui abstraitent l'exécution de la commande directe.

3. Gérer correctement l'authentification et la gestion des sessions

Les mécanismes d'autheurs faibles peuvent exposer votre application pour comptabiliser le rachat.

• Utilisez un hachage de mot de passe solide avec des algorithmes comme Bcrypt , PBKDF2 ou Argon2 - jamais stocker du texte brut ou utiliser des hachages faibles comme MD5 / SHA-1.

   // Exemple avec bcrypt
  String Hashed = bcrypt.hashpw (mot de passe, bcrypt.gensalt ());

• Utilisez une gestion sécurisée de session:

  • Régénérer les ID de session après la connexion.
  • Définir le délai d'expiration de la session.
  • Utilisez des cookies sécurisés et httponly pour les jetons de session.

• Intégrez à des cadres éprouvés comme Spring Security au lieu de faire rouler votre propre logique d'authentique.

4. Protéger les données sensibles

• Crypter les données sensibles au repos (par exemple, mot de passe, PII) à l'aide d'algorithmes forts comme AES-256.
• Utilisez javax.crypto correctement - éviter les modes faibles comme la BCE. Utilisez un cryptage authentifié (par exemple, mode GCM).
• Never Hardcode Secrets (mots de passe, touches API) dans le code source. Utilisez des variables environnementales ou sécurissez des outils de gestion secrète (par exemple, Hashicorp Vault, AWS KMS).
• Effacer les données sensibles de la mémoire une fois terminées:

   char [] mot de passe = getPassword ();
  // Utiliser le mot de passe
  Arrays.filt (mot de passe, '0'); // effacez-le

5. évitez la désérialisation peu s?re

La désérialisation des données non fiables peut entra?ner une exécution de code distante .

• évitez ObjectInputStream pour les sources non fiables.
• Si vous devez désérialiser:
  • Utilisez serialVersionUID et validez les classes.
  • Considérez des alternatives plus s?res comme JSON ou XML avec une analyse stricte (par exemple, Jackson, Jaxb).
  • Utilisez des bibliothèques comme SerialKiller pour les classes autorisées en liste blanche.

Mieux encore: utilisez des formats de transfert de données comme JSON avec mappage POJO au lieu de la sérialisation Java native.

6. sécuriser les dépendances et tenir les bibliothèques à jour

De nombreuses applications Java utilisent des bibliothèques tierces (par exemple, Apache Commons, Jackson, Log4j). Une dépendance vulnérable peut compenser l'ensemble de votre application.

• Utilisez des outils tels que OWASP Dependency-Check ou SNYK pour rechercher des vulnérabilités connues.
• Mettre à jour régulièrement les dépendances.
• Retirez les bibliothèques inutilisées pour réduire la surface d'attaque.
• Surveillez les défauts critiques comme Log4Shell (CVE-2021-44228) - ils peuvent se cacher dans les dépendances transitives.

7. Appliquer une gestion et une journalisation des erreurs appropriées

Reveiller trop dans les messages d'erreur peut aider les attaquants.

• N'exposez pas de traces de pile ou de détails internes aux utilisateurs.
• Loguez en toute sécurité les erreurs sur le serveur, mais évitez les données sensibles à la connexion (mots de passe, jetons).
• Utilisez un framework de journalisation comme SLF4J avec la connexion ou le log4j2 (avec des correctifs de sécurité appliqués).
• Assurez-vous que les journaux sont protégés contre l'accès non autorisé.

8. Appliquer le moins de privilèges et de configuration sécurisée

• Exécutez votre application Java avec un minimum de privilèges OS / utilisateur.
• Désactiver les fonctionnalités JVM indésirables (par exemple, débogage à distance dans la production).
• Définissez un Sec par la sécurité (bien que déprécié dans les versions Java plus récentes, toujours pertinentes dans les systèmes hérités).
• Harden Fichiers de la politique java.security en cas de besoin.
• Désactiver les points de terminaison indésirables dans les cadres (par exemple, les points de terminaison de l'actionneur dans Spring Boot).

Réflexions finales

Le codage sécurisé dans Java ne nécessite pas d'être un expert en cryptographie - il s'agit d'adopter des habitudes défensives et d'utiliser les bons outils. Commencez par:

• Valider toutes les entrées
• Utilisation de requêtes paramétrées
• Gérer les secrets en toute sécurité
• Garder les dépendances à jour
• Tirer parti des cadres de sécurité

La plupart des vulnérabilités proviennent de modèles connus. En suivant ces pratiques et en examinant le code avec la sécurité à l'esprit, vous pouvez réduire considérablement les risques.

Fondamentalement, si cela vient de l'extérieur, vérifiez-le, désinfectez-le et ne l'exécutez jamais aveuglément.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!