Sécurité des applications TypeScript : top 10 des vulnérabilités pour débutants

Introduction : pourquoi la sécurité des applications TypeScript est importante dès le premier jour

TypeScript est une surcouche de JavaScript qui ajoute un typage statique. De nombreux développeurs débutants pensent à tort que le typage résout automatiquement tous les problèmes de sécurité. En réalité, TypeScript est compilé en JavaScript standard, et toutes les vulnérabilités inhérentes à JS restent d'actualité. Dans cet article, nous analyserons le top 10 des vulnérabilités rencontrées par les débutants et montrerons comment les éviter.

1. XSS (Cross-Site Scripting)

Le XSS est l'une des attaques les plus courantes. Un attaquant injecte un script malveillant dans une page, qui s'exécute dans le navigateur de l'utilisateur.

Exemple de code vulnérable :

function renderUserInput(input: string): string {    return `<div>${input}</div>`;}

// L'attaquant transmet : <script>alert('XSS')</script>

Comment corriger :

Échappez toujours les entrées utilisateur. Utilisez des bibliothèques comme DOMPurify ou des méthodes d'échappement intégrées :

import DOMPurify from 'dompurify';

function safeRender(input: string): string {    const clean = DOMPurify.sanitize(input);    return `<div>${clean}</div>`;}

2. Injections SQL

Si vous construisez des requêtes SQL en concaténant des chaînes avec des entrées utilisateur, vous ouvrez la porte aux injections SQL.

Code vulnérable :

function getUser(username: string): Promise<User> {    const query = `SELECT * FROM users WHERE username = '${username}'`;    return db.execute(query);}

Version sécurisée :

function getUserSafe(username: string): Promise<User> {    const query = 'SELECT * FROM users WHERE username = $1';    return db.execute(query, [username]); // requête paramétrée}

3. Stockage non sécurisé des mots de passe

Ne stockez jamais les mots de passe en clair. Utilisez bcrypt ou argon2 pour le hachage.

import bcrypt from 'bcrypt';

async function hashPassword(password: string): Promise<string> {    const saltRounds = 12;    return bcrypt.hash(password, saltRounds);}

async function verifyPassword(password: string, hash: string): Promise<boolean> {    return bcrypt.compare(password, hash);}

4. Références directes non sécurisées aux objets (IDOR)

Lorsqu'un utilisateur peut accéder aux données d'autrui en modifiant simplement l'ID dans l'URL.

Exemple :

// Vulnérable : n'importe quel utilisateur peut obtenir n'importe quelle commandeapp.get('/api/order/:id', (req, res) => {    const order = getOrderById(req.params.id);    res.json(order);});

// Sécurisé : vérification de la propriétéapp.get('/api/order/:id', (req, res) => {    const order = getOrderById(req.params.id);    if (order.userId !== req.user.id) {        return res.status(403).json({ error: 'Forbidden' });    }    res.json(order);});

5. Utilisation de dépendances obsolètes

Les projets TypeScript utilisent souvent des paquets npm. Les versions obsolètes peuvent contenir des vulnérabilités connues.

• Exécutez régulièrement npm audit
• Utilisez npm update pour mettre à jour les paquets
• Configurez des vérifications automatiques dans le CI/CD

6. Validation insuffisante des données d'entrée

Les types TypeScript ne sont pas vérifiés à l'exécution. Validez toujours les données côté serveur.

interface UserInput {    email: string;    age: number;}

// Insuffisant : les types TypeScript ne protègent pas à l'exécutionfunction processUser(input: UserInput) {    // ...}

// Correct : utilisez Zod ou Joi pour la validationimport { z } from 'zod';

const UserSchema = z.object({    email: z.string().email(),    age: z.number().min(18).max(120)});

function processUserSafe(input: unknown) {    const validate