Démarrage

Ce guide complet offre un aperçu détaillé pour commencer avec le pare-feu Shieldon pour votre application web. Analysons cela.

Exigences du serveur

Avant d'utiliser le pare-feu Shieldon, assurez-vous que votre serveur répond aux exigences suivantes :

  • PHP >= 7.1.0
  • Extension PHP Ctype
  • Extension PHP JSON
  • GD Extension PHP (Requise pour la génération d'images de codes de vérification Captcha.)
  • Extension PHP PDO (Requis uniquement si vous souhaitez utiliser le pilote MySQL ou SQLite)
  • Extension PHP Redis (Requis uniquement si vous souhaitez utiliser le pilote Redis)

Installation

Shieldon peut être installé via Composer pour PHP :

composer require shieldon/shieldon

Mise en œuvre

Il existe trois principales façons de mettre en œuvre Shieldon dans votre application :

  • Implémenter Shieldon en tant que middleware PSR-15.
  • Implémenter Shieldon dans la phase d'amorçage de votre application.
  • Implémenter Shieldon dans un contrôleur parent dont d'autres contrôleurs héritent.

Chaque méthode d'implémentation est accompagnée d'exemples pratiques utilisant des frameworks populaires tels que Slim 4, Laravel 6 et CodeIgniter 3.

Middleware PSR-15

Exemple : Framework Slim 4

Shieldon peut être utilisé comme middleware PSR-15, comme illustré dans l'exemple utilisant le framework Slim 4.

(1) Créer un middleware pour le pare-feu.

class FirewallMiddleware
{
    /**
     * Classe invocable du middleware d'exemple
     *
     * @param ServerRequest  $request  Requête PSR-7
     * @param RequestHandler $handler  Gestionnaire de requêtes PSR-15
     *
     * @return Response
     */
    public function __invoke(Request $request, RequestHandler $handler): Response
    {
        $response = $handler->handle($request);

        $firewall = new \Shieldon\Firewall\Firewall($request, $response);

        // Le répertoire dans lequel Shieldon Firewall placera ses fichiers.
        $firewall->configure(__DIR__ . '/../cache/shieldon_firewall');
        $response = $firewall->run();

        if ($response->getStatusCode() !== 200) {
            $httpResolver = new \Shieldon\Firewall\HttpResolver();
            $httpResolver($response);
        }

        return $response;
    }
}

(2) Ajouter le middleware du pare-feu dans votre application.

Par exemple, si vous utilisez le framework Slim 4, le code devrait ressembler à ceci :

$app->add(new FirewallMiddleware());

(3) Créer une route pour le panneau de contrôle.

Par exemple, si vous utilisez le framework Slim 4, le code devrait ressembler à ceci. Ensuite, vous pouvez accéder à l'URL https://votresite.com/firewall/panel pour vous connecter au panneau de contrôle.

$app->any('/firewall/panel[/{params:.*}]', function (Request $request, Response $response, $args) {
    $firewall = new \Shieldon\Firewall\Firewall($request, $response);

    // Le répertoire dans lequel Shieldon Firewall placera ses fichiers.
    // Doit être identique à FirewallMiddleware.
    $firewall->configure(__DIR__ . '/../cache/shieldon_firewall');

    $panel = new \Shieldon\Firewall\Panel();

    // L'URL de base pour le panneau de contrôle.
    $panel->entry('/firewall/panel/');
});

Remarque :

  • Les méthodes HTTP POST et GET doivent toutes deux s'appliquer à votre site web.
  • La méthode POST est nécessaire pour résoudre les CAPTCHA par les utilisateurs temporairement bloqués.

Phase d'amorçage

Exemple : Framework Laravel 6

Vous pouvez initialiser Shieldon dans la phase d'amorçage de votre application, comme illustré dans l'exemple utilisant le framework Laravel 6.

(1) Avant d'initialiser $app

Dans votre fichier bootstrap/app.php, après <?php, ajoutez le code suivant.

/*
|--------------------------------------------------------------------------
| Exécution du pare-feu Shieldon
|--------------------------------------------------------------------------
|
| Le pare-feu Shieldon surveillera toutes les requêtes HTTP arrivant sur votre site web.
| Exécuter le pare-feu Shieldon avant d'initialiser Laravel évitera les éventuels
| conflits avec les fonctions intégrées de Laravel.
*/
if (isset($_SERVER['REQUEST_URI'])) {

    // Ce répertoire doit être accessible en écriture.
    // Nous le plaçons dans le répertoire `storage/shieldon_firewall`.
    $storage =  __DIR__ . '/../storage/shieldon_firewall';

    $firewall = new \Shieldon\Firewall\Firewall();
    $firewall->configure($storage);
    $response = $firewall->run();

    if ($response->getStatusCode() !== 200) {
        $httpResolver = new \Shieldon\Firewall\HttpResolver();
        $httpResolver($response);
    }
}

(2) Définir une route pour le panneau de contrôle du pare-feu.

Route::any('/firewall/panel/{path?}', function() {

    $panel = new \Shieldon\Firewall\Panel();
    $panel->csrf(['_token' => csrf_token()]);

    // Le point d'entrée doit être identique à la route définie.
    $panel->entry('/firewall/panel/');

})->where('path', '(.*)');

Contrôleur parent

Exemple : Framework CodeIgniter 3

Shieldon peut également être implémenté dans un contrôleur parent dont d'autres contrôleurs héritent, comme illustré dans l'exemple utilisant le framework CodeIgniter 3.

  1. Créer un contrôleur parent.

Créez un nouveau fichier MY_Controller.php dans le répertoire application/core/. Ce sera votre contrôleur parent.

Voici la structure de base de MY_Controller :

class MY_Controller extends CI_Controller
{
    public function __construct()
    {
        parent::__construct();
    }
}
  1. Initialiser une instance du pare-feu

Ensuite, initialisez le pare-feu Shieldon dans le constructeur de MY_Controller. Cela garantira que le pare-feu Shieldon est initialisé pour chaque contrôleur qui hérite de MY_Controller.

class MY_Controller extends CI_Controller
{
    public function __construct()
    {
        parent::__construct();

        // Autoloader Composer
        require_once APPPATH . '../vendor/autoload.php';

        // Ce répertoire doit être accessible en écriture.
        $storage = APPPATH . 'cache/shieldon_firewall';

        $firewall = new \Shieldon\Firewall\Firewall();
        $firewall->configure($storage);
        $response = $firewall->run();

        if ($response->getStatusCode() !== 200) {
            $httpResolver = new \Shieldon\Firewall\HttpResolver();
            $httpResolver($response);
        }
    }

    /**
     * Protection du pare-feu Shieldon.
     */
    public function firewall()
    {
        $firewall = \Shieldon\Container::get('firewall');
        $firewall->run();
    }
}
  1. Définir un contrôleur pour le panneau de contrôle.

Ensuite, vous devez définir un contrôleur pour le panneau de contrôle du pare-feu Shieldon. Dans cet exemple, vous créerez un contrôleur appelé Firewall.

Créez un nouveau fichier Firewall.php dans le répertoire application/controllers/ et ajoutez le code suivant :

class Firewall extends MY_Controller
{
    public function __construct()
    {
        parent::__construct();
    }

    /**
     * C'est le point d'entrée de notre panneau de contrôle du pare-feu.
     */
    public function panel()
    {
        $panel = new \Shieldon\Firewall\Panel();
        $panel->entry('/firewall/panel/');
    }
}

Maintenant, le pare-feu Shieldon est initialisé dans votre MY_Controller, et chaque contrôleur qui hérite de MY_Controller et exécute la méthode firewall y a accès. De plus, vous avez défini un contrôleur Firewall avec une méthode panel, qui est votre point d'entrée vers le panneau de contrôle du pare-feu Shieldon.

Connexion

Enfin, quel que soit la méthode d'implémentation choisie, l'accès à https://votresite.com/firewall/panel/ affichera la page de connexion.

Le nom d'utilisateur et le mot de passe par défaut sont shieldon_user et shieldon_pass, respectivement. Pour des raisons de sécurité, il est vivement recommandé de changer les informations d'identification de connexion après la première connexion.