Comment sécuriser votre API contre les requêtes non autorisées

Dans les applications modernes, les API jouent un rôle essentiel en connectant différents systèmes. Cependant, les API sont également des cibles courantes d’accès non autorisés et d’abus. La sécurité des API nécessite plusieurs couches de protection, combinant une validation CORS, des mécanismes d'authentification forts et une surveillance fiable. Cet article décrira plusieurs stratégies pour sécuriser votre API afin de garantir que seuls les clients de confiance peuvent y accéder.

---

1. Configurer correctement CORS

Le partage de ressources entre origines croisées (CORS) est un mécanisme de sécurité important qui détermine quelles origines peuvent interagir avec votre API. Une configuration correcte de CORS est essentielle pour empêcher tout accès non autorisé.

Exemple ASP.NET Core :

<code class="language-csharp">builder.Services.AddCors(options =>
{
    options.AddPolicy("RestrictOrigins", policy =>
    {
        policy.WithOrigins("https://mywebsite.com", "https://trustedpartner.com") // 允许的来源
              .AllowAnyHeader()
              .AllowAnyMethod();
    });
});

// 应用 CORS 策略
app.UseCors("RestrictOrigins");</code>

Règles clés :

• Éviter AllowAnyOrigin : autoriser toutes les origines rend votre API vulnérable.
• N'utilisez pas SetIsOriginAllowed(_ => true) : cela contournera complètement la vérification de l'origine.
• Limiter les méthodes et les en-têtes : limitez AllowAnyMethod et AllowAnyHeader à la portée strictement nécessaire.

---

2. Mettre en œuvre l'authentification et l'autorisation

L'authentification garantit que seuls les utilisateurs ou systèmes autorisés peuvent accéder à vos points de terminaison. Une méthode courante consiste à utiliser des jetons Web JSON (JWT).

Étapes de mise en œuvre de JWT :

1. Côté client, envoyez le JWT dans l'en-tête de la requête :

<code>   Authorization: Bearer <your-jwt-token></code>

2. Côté serveur, vérifiez le token :

<code class="language-csharp">   app.UseAuthentication();
   app.UseAuthorization();</code>

Exemple de configuration ASP.NET Core :

<code class="language-csharp">builder.Services.AddAuthentication("Bearer")
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = "https://mywebsite.com",
            ValidAudience = "https://mywebsite.com",
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("secret-key"))
        };
    });</code>

---

3. Vérifiez explicitement l'en-tête Origin

Même si CORS est configuré, vous pouvez ajouter une couche de sécurité supplémentaire en validant manuellement l'en-tête Origin dans le middleware côté serveur.

Exemple :

<code class="language-csharp">app.Use(async (context, next) =>
{
    var origin = context.Request.Headers["Origin"].ToString();
    var allowedOrigins = new[] { "https://mywebsite.com", "https://trustedpartner.com" };

    if (!string.IsNullOrEmpty(origin) && !allowedOrigins.Contains(origin))
    {
        context.Response.StatusCode = StatusCodes.Status403Forbidden;
        await context.Response.WriteAsync("Origin not allowed.");
        return;
    }

    await next();
});</code>

---

4. Bloquer les adresses IP suspectes

Filtrez et bloquez les requêtes provenant d'adresses IP malveillantes connues pour réduire les vecteurs d'attaque.

Exemple de middleware :

<code class="language-csharp">app.Use(async (context, next) =>
{
    var clientIp = context.Connection.RemoteIpAddress;
    var blockedIps = new[] { "192.168.1.100", "10.0.0.50" };

    if (blockedIps.Contains(clientIp.ToString()))
    {
        context.Response.StatusCode = StatusCodes.Status403Forbidden;
        await context.Response.WriteAsync("Blocked IP.");
        return;
    }

    await next();
});</code>

---

5. Mettre en œuvre une limitation de débit

Protégez votre API contre les abus et les attaques par force brute en limitant le nombre de requêtes qu'un client peut effectuer.

Exemple ASP.NET Core :

Installez le package :

<code class="language-bash">dotnet add package AspNetCoreRateLimit</code>

Configurer la limite de débit :

<code class="language-csharp">builder.Services.AddMemoryCache();
builder.Services.Configure<IpRateLimitOptions>(options =>
{
    options.GeneralRules = new List<RateLimitRule>
    {
        new RateLimitRule
        {
            Endpoint = "*",
            Limit = 100, // 请求限制
            Period = "1m" // 每分钟
        }
    };
});

builder.Services.AddInMemoryRateLimiting();
app.UseIpRateLimiting();</code>

---

6. Utilisez HTTPS pour toutes les connexions

Assurez une communication sécurisée entre les clients et votre API en forçant l'utilisation du HTTPS.

Configurer HTTPS dans ASP.NET Core :

<code class="language-csharp">webBuilder.UseKestrel()
          .UseHttps();</code>

Rediriger le trafic HTTP vers HTTPS :

<code class="language-csharp">app.UseHttpsRedirection();</code>

---

7. Demandes de surveillance et de journalisation

Implémentez la journalisation pour détecter les modèles inhabituels, tels que plusieurs requêtes provenant de sources inconnues.

Exemple :

<code class="language-csharp">app.Use(async (context, next) =>
{
    var origin = context.Request.Headers["Origin"].ToString();
    Console.WriteLine($"Request from origin: {origin}");
    await next();
});</code>

Utilisez des outils tels que Application Insights, Serilog ou Elastic Stack pour une surveillance complète.

---

8. Évitez les réponses d'erreur détaillées

N'exposez pas d'informations sensibles dans les messages d'erreur, car cela pourrait aider les attaquants.

Exemple :

<code class="language-csharp">builder.Services.AddCors(options =>
{
    options.AddPolicy("RestrictOrigins", policy =>
    {
        policy.WithOrigins("https://mywebsite.com", "https://trustedpartner.com") // 允许的来源
              .AllowAnyHeader()
              .AllowAnyMethod();
    });
});

// 应用 CORS 策略
app.UseCors("RestrictOrigins");</code>

---

Conclusion

Sécuriser votre API contre les requêtes non autorisées nécessite une approche à plusieurs niveaux :

1. Configurez correctement CORS.
2. Vérifiez explicitement les sources et les en-têtes.
3. Implémente l'Authentification et la Limitation de débit.
4. Utilisez HTTPS et surveillez le trafic.

En suivant ces bonnes pratiques, vous pouvez réduire considérablement le risque d'accès non autorisé et garantir que seuls les clients de confiance peuvent interagir avec votre API.

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!