Sécuriser une API REST en 2025

15 janvier 2025

SécuritéAPIBackend

Introduction

La sécurité des APIs REST est plus cruciale que jamais en 2025. Avec l’augmentation des cyberattaques et des violations de données, il est essentiel de mettre en place des mesures de sécurité robustes dès la conception de votre API.

Dans cet article, je partage les meilleures pratiques que j’applique sur mes projets pour garantir la sécurité des APIs.

1. Authentification et autorisation

JWT (JSON Web Tokens)

Les JWT restent un standard pour l’authentification des APIs. Voici les points clés :

// Exemple de génération de JWT sécurisé
const jwt = require('jsonwebtoken');

function generateToken(user) {
  return jwt.sign(
    {
      userId: user.id,
      role: user.role
    },
    process.env.JWT_SECRET,
    {
      expiresIn: '15m',
      algorithm: 'HS256'
    }
  );
}

Points importants :

Utilisez des tokens courte durée (15-30 minutes)
Implémentez un système de refresh tokens
Stockez le secret JWT de manière sécurisée
Ne jamais inclure de données sensibles dans le payload

OAuth 2.0 et OpenID Connect

Pour les applications nécessitant une authentification tierce :

Privilégiez OAuth 2.0 avec PKCE pour les applications mobiles
Utilisez OpenID Connect pour l’authentification
Validez toujours les tokens côté serveur

2. Rate Limiting

Le rate limiting protège contre les attaques par force brute et les DDoS.

// Exemple avec express-rate-limit
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // limite par IP
  message: 'Trop de requêtes, réessayez plus tard'
});

app.use('/api/', limiter);

Bonnes pratiques :

Différents limites selon les endpoints
Rate limiting par IP et par utilisateur
Implémentez des stratégies de back-off
Logging des tentatives excessives

3. Validation des données

Ne jamais faire confiance aux données entrantes.

// Exemple avec Joi
const Joi = require('joi');

const userSchema = Joi.object({
  email: Joi.string().email().required(),
  password: Joi.string().min(8).required(),
  name: Joi.string().max(100).required()
});

app.post('/api/users', async (req, res) => {
  const { error } = userSchema.validate(req.body);
  if (error) {
    return res.status(400).json({ error: error.details[0].message });
  }
  // Continuer le traitement
});

4. Protection contre les injections

SQL Injection

Utilisez toujours des requêtes paramétrées :

// ❌ Mauvais
const query = `SELECT * FROM users WHERE email = '${email}'`;

// ✅ Bon
const query = 'SELECT * FROM users WHERE email = ?';
db.query(query, [email]);

NoSQL Injection

Même avec MongoDB, validez les entrées :

// ❌ Mauvais
const user = await User.findOne({ email: req.body.email });

// ✅ Bon
const email = validator.escape(req.body.email);
const user = await User.findOne({ email });

5. HTTPS et certificats

En 2025, HTTPS n’est plus optionnel :

Utilisez des certificats TLS 1.3
Forcez HTTPS avec HSTS
Implémentez Certificate Pinning pour les applications mobiles
Vérifiez régulièrement la validité des certificats

// Forcer HTTPS
app.use((req, res, next) => {
  if (!req.secure && req.get('x-forwarded-proto') !== 'https') {
    return res.redirect('https://' + req.get('host') + req.url);
  }
  next();
});

6. CORS (Cross-Origin Resource Sharing)

Configurez CORS de manière restrictive :

const cors = require('cors');

app.use(cors({
  origin: ['https://votre-domaine.com'],
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  credentials: true,
  maxAge: 86400
}));

7. Logging et monitoring

Implémentez un système de logging robuste :

Loggez toutes les tentatives d’authentification
Surveillez les patterns suspects
Alertes en temps réel pour les anomalies
Stockez les logs de manière sécurisée
Respectez le RGPD (pas de données personnelles dans les logs)

const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

// Middleware de logging
app.use((req, res, next) => {
  logger.info({
    method: req.method,
    url: req.url,
    ip: req.ip,
    timestamp: new Date()
  });
  next();
});

8. Headers de sécurité

Utilisez helmet.js pour configurer les headers de sécurité :

const helmet = require('helmet');

app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      styleSrc: ["'self'", "'unsafe-inline'"]
    }
  },
  hsts: {
    maxAge: 31536000,
    includeSubDomains: true,
    preload: true
  }
}));

9. Gestion des erreurs

Ne jamais exposer les détails des erreurs en production :

app.use((err, req, res, next) => {
  logger.error(err.stack);

  if (process.env.NODE_ENV === 'production') {
    res.status(500).json({ error: 'Une erreur est survenue' });
  } else {
    res.status(500).json({ error: err.message, stack: err.stack });
  }
});

10. Tests de sécurité

Intégrez la sécurité dans votre CI/CD :

Tests de pénétration réguliers
Scan automatique des dépendances (npm audit, Snyk)
Analyse statique du code (SonarQube)
Tests d’intrusion automatisés

Checklist de sécurité

Avant de déployer votre API :

Conclusion

La sécurité d’une API REST nécessite une approche multicouche. Aucune mesure unique ne suffit ; c’est la combinaison de toutes ces pratiques qui rend votre API robuste face aux menaces.

N’oubliez pas que la sécurité est un processus continu, pas un état final. Restez informé des nouvelles vulnérabilités et mettez à jour vos pratiques régulièrement.