image
Semah
Sécurité

🔐 Comment sécuriser correctement une API .NET — Guide simple & moderne

La sécurité d’une API n’est plus un “plus”, c’est un prérequis. Les applications modernes (web, mobile, microservices, IoT) reposent toutes sur des API, et la moindre faille peut exposer des données critiques.

L’objectif de cet article :
👉 expliquer simplement comment sécuriser une API .NET moderne, sans jargon inutile,
👉 en mettant en avant les bonnes pratiques réellement utilisées en entreprise.

🧱 1. Comprendre le modèle : Authentification vs Autorisation

Avant de parler tokens ou claims, il faut clarifier la base.

🔑 Authentification → Qui es-tu ?

C’est l’étape qui vérifie l’identité de l’utilisateur (email + mot de passe, OAuth, SSO, etc.).

🚦 Autorisation → Que peux-tu faire ?

C’est le contrôle permettant de dire :

  • un admin peut modifier
  • un utilisateur peut lire
  • un invité ne peut rien faire

Ces deux notions sont différentes… mais souvent mélangées.
.NET les sépare bien : AddAuthentication() puis AddAuthorization().

🪙 2. Protéger l’API avec JWT (Json Web Token)

Le format JWT est devenu standard dans les APIs REST.

Un JWT contient :

  • les infos de l’utilisateur (claims)
  • une signature qui garantit l’intégrité
  • une date d’expiration

L’API peut valider le token sans interroger la base de données → très performant.

Exemple minimal :

builder.Services.AddAuthentication("Bearer")
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = "https://mon-api.com",
            ValidAudience = "https://mon-api.com",
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes("MaCléUltraSecrète123!"))
        };
    });

Et dans les contrôleurs :

[Authorize]
[HttpGet("profile")]
public IActionResult GetProfile() => Ok("Accès autorisé ✔️");

Simple et propre.

🔄 3. Ajouter un Refresh Token (sinon votre API n’est pas réellement sécurisée)

Beaucoup d’APIs se contentent du JWT.
Grosse erreur.

Un JWT expire vite (5–30 minutes).
Si vous obligez l’utilisateur à se reconnecter → expérience horrible.

👉 La solution :

  • Émettre un refresh token longue durée
  • Stocké côté serveur (BDD ou Redis)
  • Permet de régénérer un nouvel access token

C’est aujourd’hui l’approche recommandée dans 95% des architectures.

🧰 4. Utiliser les Policies .NET (bien meilleur que le “role-based”)

Le vieux modèle Roles = "Admin" est limité.

Les policies, c’est la version moderne :

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("CanDeleteUser", policy =>
        policy.RequireClaim("permission", "delete_user"));
});

Et dans un contrôleur :

[Authorize(Policy = "CanDeleteUser")]
public IActionResult DeleteUser() => Ok();

👉 Beaucoup plus flexible
👉 Adapté aux applications complexes
👉 Parfait avec des microservices

🚦 5. Filtrer et limiter les appels (Rate Limiting .NET 8)

Très gros sujet d’actualité.

.NET 8 intègre nativement un rate limiting qui protège contre :

  • les bots
  • les attaques par force brute
  • les milliers de requêtes/sec non contrôlées

Exemple :

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("apiLimiter", opt =>
    {
        opt.Window = TimeSpan.FromSeconds(10);
        opt.PermitLimit = 30;
    });
});

Et on applique sur une route :

[EnableRateLimiting("apiLimiter")]

Excellent pour les APIs publiques.

🛡️ 6. Toujours utiliser HTTPS + HSTS

Règles simples :
✔️ HTTPS obligatoire
✔️ HSTS activé
✔️ Redirections HTTP → HTTPS
✔️ Pas de token dans l’URL (jamais)

Une API en HTTP = token exposé = sécurité détruite.

🧲 7. Ne jamais exposer trop d’infos dans vos erreurs

Erreur classique : renvoyer des détails sensibles.

❌ Mauvais exemple :

Erreur SQL : colonne password_hash introuvable

✔️ Bon exemple :

Une erreur interne est survenue.

Et on logue le détail côté serveur (Serilog, ELK, Seq…).

🧽 8. Valider les données en entrée

On ne le dit pas assez :

👉 70% des failles viennent de données non validées

En .NET, on utilise :

  • les DataAnnotations
  • ou FluentValidation (recommandé)

Exemple :

RuleFor(x => x.Email)
    .NotEmpty()
    .EmailAddress();

Très simple, très puissant.

🕵️‍♂️ 9. Éviter les pièges courants

Voici les erreurs qu’on voit tous les jours en entreprise :

ErreurPourquoi c’est grave
Mettre la clé JWT dans appsettings.jsonfuite = API ouverte
Laisser swagger sans authentificationdangereux en production
Access token longue duréesi volé → catastrophe
Pas de CORSAPI vulnérable au vol de token
Stockage du refresh token en localStorageXSS = token volé

Une API sécurisée, c’est souvent “moins de code, mais mieux organisé”.

🎯 Conclusion : Sécuriser une API, ce n’est pas compliqué… si on suit les bons standards

Pour avoir une API .NET vraiment robuste, il suffit de retenir :

✔️ JWT + refresh token
✔️ Policies modernes (pas les rôles “old school”)
✔️ Rate limiting .NET 8
✔️ Validation propre des données
✔️ HTTPS + HSTS
✔️ Logs internes, erreurs anonymisées
✔️ Jamais de secrets dans le code

Ces pratiques sont exactement celles utilisées chez AXA, Enedis, GTA, etc.
Tu peux donc le dire clairement : tu maîtrises la sécurité API moderne.

Leave a Comment