Limitation de courant et anti-brushing de l'interface ThinkPHP6 : protéger la sécurité de l'interface

Limitation de courant et anti-swiping de l'interface ThinkPHP6 : protéger la sécurité de l'interface

Dans les applications Internet modernes, l'utilisation d'interfaces est de plus en plus répandue et de nombreuses applications s'appuient sur diverses interfaces pour la transmission et l'interaction des données. Cependant, en raison de l’ouverture et de la commodité des interfaces, elles constituent également des cibles faciles pour les attaquants. Il devient donc crucial de protéger la sécurité des interfaces. Dans le framework ThinkPHP6, certains mécanismes de protection et restrictions sont fournis pour nous aider à protéger efficacement la sécurité de l'interface.

1. Limitation du courant de l'interface

La limitation du courant de l'interface fait référence à la limitation de la fréquence des requêtes d'une interface pour éviter qu'une interface ne soit abusée par un trop grand nombre de requêtes. ThinkPHP6 implémente la limitation du courant d'interface en utilisant un middleware. L'exemple est le suivant :

1. Créez un fichier middleware :

Dans le répertoire app/middleware, créez un fichier ApiLimiter.php avec le contenu suivant :

<?php
namespace appmiddleware;

class ApiLimiter
{
    public function handle($request, Closure $next)
    {
        // 获取请求的路由信息等，根据具体情况进行限流
        // 这里以请求路径作为示例
        $route = $request->pathinfo();
        $cacheKey = 'api_limiter_'.$route;

        // 判断缓存中的请求次数，如果超过了限定次数，则返回请求频繁的错误信息
        if(cache($cacheKey) >= 10) {
            return json([
                'code' => 400,
                'message' => '请求频繁，请稍后再试',
                'data' => null
            ]);
        }

        // 如果没有超过限定次数，则继续执行请求，并将请求次数加1
        cache($cacheKey, cache($cacheKey) + 1, 60); // 缓存的时间可以根据实际需求进行调整

        return $next($request);
    }
}

2. le fichier middleware :

Dans le fichier app/middleware.php, enregistrez le middleware que nous avons créé :

<?php
// 注册中间件
return [
    // ...
    appmiddlewareApiLimiter::class
    // ...
];

3. Utiliser le middleware :

Utiliser le middleware dans la définition de l'itinéraire :

<?php
Route::group('/api/', function () {
    // ...
    Route::rule('example', 'api/example')->middleware(appmiddlewareApiLimiter::class);
    // ...
});

Grâce à la configuration ci-dessus, nous pouvons atteindre Le la fréquence des requêtes de l'interface /api/example est limitée, permettant jusqu'à 10 requêtes par minute.

2. Mécanisme anti-brossage

En plus de la limitation du courant de l'interface, nous pouvons également utiliser le mécanisme anti-brossage pour protéger davantage la sécurité de l'interface. ThinkPHP6 fournit une méthode pratique pour empêcher le swiping, c'est-à-dire l'utilisation de jetons.

1. Générer un jeton :

Une fois que l'utilisateur s'est connecté avec succès, générez un jeton et renvoyez-le au client. La méthode de génération des tokens peut être déterminée en fonction des besoins réels. Voici un exemple :

<?php
use thinkacadeCache;

function generateToken($userId)
{
    $token = md5(uniqid() . $userId);
    Cache::set('token_'.$token, $userId, 3600); // 令牌有效时间为1小时

    return $token;
}

2. Vérifier le token :

Dans l'interface, à chaque fois que le client demande, il est nécessaire de vérifier si le token est passé par le le client est valide :

<?php
use thinkacadeCache;

function validateToken($token)
{
    $userId = Cache::get('token_'.$token);
    if(!$userId) {
        // 令牌无效，返回错误信息
        return false;
    }

    // 令牌有效，可以继续执行接口逻辑
    // 在这里可以获取到$userID，可以根据用户ID做进一步的操作，例如校验用户权限等

    return true;
}

Grâce aux méthodes ci-dessus, nous pouvons restreindre et protéger efficacement l'accès à l'interface. Dans les projets réels, des stratégies de restriction plus complexes et flexibles peuvent être personnalisées en fonction des besoins et des conditions réelles, telles que des restrictions basées sur l'adresse IP, des restrictions basées sur les rôles des utilisateurs, etc.

Résumé :

La sécurité des interfaces est cruciale pour les applications Internet modernes. Grâce à des mécanismes raisonnables de limitation du courant d'interface et d'anti-brossage, nous pouvons protéger la sécurité de l'interface et prévenir les abus et les attaques. Dans le framework ThinkPHP6, les mécanismes middleware et token fournissent des méthodes de mise en œuvre pratiques et peuvent être appliqués de manière flexible à divers projets. Pendant le processus de développement, nous devons accorder plus d'attention à la sécurité des interfaces et faire les choix techniques et les implémentations correspondants en fonction de la situation réelle. Ce n'est qu'en garantissant la sécurité de l'interface que nous pourrons mieux protéger la confidentialité des utilisateurs et la stabilité des applications.

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!