Le Rayon UX

La radiographie du Web en temps presque réel / thème en chantier (je m'appelle Teuse)

Les 25 erreurs de programmation les plus dangereuses

Comme chaque année, le CWE vient de publier la liste des 25 erreurs de programmation les plus dangereuses pour l’intégrité de vos systèmes ou de vos applications. Si toutes ces vulnérabilités ne s’appliquent pas forcément au développement web, elles sont tout de même intéressantes à étudier, ne serait-ce que pour se former aux bonnes pratiques de développement.

Mauvaises interactions entre les composants

Ces vulnérabilités concernent les manières dont les données sont envoyées et reçues par des composants, modules, programmes, processus, threads ou systèmes.

  1. Mauvais filtrage des données envoyées par les utilisateurs.
  2. Mauvais encodage ou échappement des données en sortie.
  3. Injections SQL.
  4. Cross Site Scripting (ou XSS).
  5. Injection de commandes directement exécutables par le système d’exploitation (system() ou exec()).
  6. CSRF (prononcez sea surf pour avoir l’air cool).
  7. Race conditions.
  8. Divulgation d’informations dans les messages d’erreur (comme le PATH dans lequel est installée votre application web).

Mauvaise gestion des ressources

Ces vulnérabilités concernent la manière dont les applications ne gèrent pas correctement la création, l’utilisation, le transfert et la destruction des ressources systèmes.

  1. Buffer overflow.
  2. Modifications externes de données d’état.
  3. Modification externe des chemins d’accès ou des fichiers en lecture / écriture.
  4. PATH non limité.
  5. Injections de code (eval()).
  6. Téléchargement et exécution de code sans réel contrôle d’intégrité.
  7. Mauvaise libération de ressources (double free()…).
  8. Mauvaise initialisation.
  9. Erreurs de calcul (off by one, division par zéro).

Protections foireuses

Il s’agit de modes de protection souvent mal utilisés, contournés, ou purement ignorés par les développeurs.

  1. Absence d’ACL.
  2. Utilisation d’un algorithme de chiffrement cassé.
  3. Mots de passes codés en dur dans les applications(!).
  4. Mauvaises permissions sur les ressources les plus critiques.
  5. Exécution de programmes avec des permissions trop élevées (le bonheur des CGI en root).
  6. Prise des mesures de sécurité côté client.

Voilà, c’est tout, avec, peut-être, à l’avenir, des articles distincts sur chacune de ces vulnérabilités, si vous êtes suffisamment nombreux à être intéressés.

  • Par Christophe Lauer [MS] 06/02/2009 at 01h43

    Le pire, c’est qu’en parcourant cette liste un peu rapidement, je n’ai pas l’impression que la situation se soit nettement améliorée depuis les dernières années.

    J’ai même l’impression qu’avec l’apparente facilité de bricoler trois bouts de scripts, et le fait que demain n’importe quel quidamme pouvant prétendre être un “développeur ouaibe”, ça risque de devenir de plus en plus critique…

    Parce qu’il n’y a rien qui ressemble plus à un nouveau service “bêta” sérieux et proprement sécurisé qu’un autre service “bêta” qui serait au contraire une vraie passoire.

    Ô Rage, ô Désespoir !


  • Par Christophe Lauer [MS] 06/02/2009 at 01h45

    Mon ami Sébastien de l’OWASP France à encore du boulot devant lui ! http://www.owasp.org/index.php/Main_Page


  • Par Philippe 06/02/2009 at 05h02

    “des articles distincts sur chacune de ces vulnérabilités”

    Quelle bonne idée !


  • Par Benoit 06/02/2009 at 11h07

    C’est vrai qu’il y a beaucoup de développeurs peu attentifs à ces aspects de sécurité, qui se contentent de copier/coller vite fait des bouts de scripts sans comprendre la logique derrière le code…

    J’ai écrit il y a quelques temps des exemples sur le top 5 de ces vulnérabilités. Si ça vous intéresse, http://bcolin.com/index/les-5-points-securite-que-vous-devez-verifier-avant-de-livrer


  • Par max 07/02/2009 at 16h48

    Je plussoie pour un article par erreur !


  • Par odenis 09/02/2009 at 09h17

    Bon j’avoue j’en ai déjà commis quelques une ;)


  • Par devis assurance 29/12/2009 at 12h14

    J’ai même l’impression qu’avec l’apparente facilité de bricoler trois bouts de scripts, et le fait que demain n’importe quel quidamme pouvant prétendre être un “développeur ouaibe”, ça risque de devenir de plus en plus critique…


Commentaire Les 25 erreurs de programmation les plus dangereuses