Comment fournir une authentification pour un service Web à l'aide du framework Silex ?

Silex est un framework web léger basé sur le langage PHP. Il fournit une série de composants et d'outils pour rendre le développement web plus simple et plus efficace. Parmi eux, l'authentification est l'un des maillons importants dans la création de services Web. Elle peut garantir que seuls les utilisateurs autorisés peuvent accéder au service. Dans le framework Silex, l'utilisation de l'authentification nécessite une certaine configuration et implémentation de code. Dans cet article, nous présenterons comment utiliser l'authentification dans le framework Silex.

1. Idée de base

Dans le framework Silex, l'authentification peut être réalisée en utilisant le composant Symfony Security. Le processus de base est le suivant :

1. Obtenir les informations d'identité fournies par l'utilisateur, telles que le nom d'utilisateur et le mot de passe.
2. Utilisez les informations d'identité obtenues pour l'authentification de l'identité Si l'authentification réussit, un certificat d'authentification sera généré.
3. Utilisez les informations d'authentification pour le contrôle d'accès dans les demandes ultérieures.

2. Installez les composants nécessaires

Pour utiliser le composant Symfony Security, vous devez installer les composants nécessaires dans le framework Silex Security peut être facilement. installé via les composants Composer et d’autres composants dépendants. Créez un fichier composer.json dans le répertoire racine du projet et ajoutez le contenu suivant :

{
    "require": {
        "silex/silex": "~2.0",
        "symfony/security": "^4.3"
    },
    "autoload": {
        "psr-4": { "": "src/" }
    }
}

Exécutez ensuite la commande composer install pour installer les composants dépendants.

3. Configurer les informations d'authentification

La configuration des informations d'authentification nécessite de définir un service de sécurité dans le framework Silex, et doit également spécifier un fournisseur d'identité et un fournisseur d'utilisateurs pour ce service de sécurité . Le fournisseur d'identité est responsable de la vérification des informations d'identité et le fournisseur d'utilisateurs est responsable de fournir les détails de l'utilisateur. Pour les applications Web simples, ces deux services peuvent utiliser la même implémentation. Ajoutez le code suivant à app.php :

use SymfonyComponentSecurityCoreUserInMemoryUserProvider;
use SymfonyComponentSecurityCoreUserUser;
use SymfonyComponentSecurityCoreUserUserProviderInterface;

$app->register(new SilexProviderSecurityServiceProvider());

$app['security.firewalls'] = array(
    'secured' => array(
        'pattern' => '^/secured',
        'http' => true,
        'users' => function() use($app){
            return new InMemoryUserProvider(
                array(
                    'admin' => array('ROLE_USER', 'password')
                )
            );
        }
    )
);

$app['security.access_rules'] = array(
    array('^/secured', 'ROLE_USER')
);

$app['security.role_hierarchy'] = array(
    'ROLE_ADMIN' => array('ROLE_USER')
);

$app['security.user_provider'] = function($app) {
    return new UserProvider($app['db']);
};

$app['security.encoder.bcrypt'] = $app->share(function($app) {
    return new BCryptPasswordEncoder($app['security.encoder.bcrypt.cost']);
});

$app['security.authentication_listener.factory.form'] = $app->protect(function ($name, $options) use ($app) {
    $app['security.authentication_provider.'.$name.'.form'] = function () use ($app) {
        return new FormAuthenticationProvider(
            $app['security.user_provider'],
            $app['security.encoder_factory']
        );
    };
 
    $app['security.authentication_listener.'.$name.'.form'] = function () use ($app, $name, $options) {
        return new FormAuthenticationListener(
            $app['security'],
            $app['security.authentication_manager'],
            $name,
            $options,
            new UsernamePasswordFormAuthenticationEntryPoint(
                $app,
                $app['security.http_utils'],
                $name
            ),
            $app['logger'],
            $app['dispatcher'],
            $app['security.authentication.session_strategy']
        );
    };
 
    return array(
        'security.authentication_provider.'.$name.'.form',
        'security.authentication_listener.'.$name.'.form',
        null,
        'pre_auth'
    );
});

4. Créer un fournisseur d'utilisateurs (UserProvider)

La création d'un fournisseur d'utilisateurs nécessite l'implémentation de l'interface SymfonyComponentSecurityCoreUserUserProviderInterface, qui contient quelques méthodes utiles. pour obtenir des informations sur les utilisateurs. Créez un UserProvider dans app.php et ajoutez le code suivant :

use SymfonyComponentSecurityCoreUserUserProviderInterface;
use SymfonyComponentSecurityCoreUserUserInterface;
use SymfonyComponentSecurityCoreExceptionUnsupportedUserException;

class UserProvider implements UserProviderInterface
{
    private $db;

    public function __construct(Connection $db)
    {
        $this->db = $db;
    }

    public function loadUserByUsername($username)
    {
        $stmt = $this->db->executeQuery('SELECT * FROM users WHERE username = ?', array(strtolower($username)));

        if (!$user = $stmt->fetch()) {
            throw new UsernameNotFoundException(sprintf('Username "%s" does not exist.', $username));
        }

        $rolesStmt = $this->db->executeQuery('SELECT roles.role FROM user_roles JOIN roles ON user_roles.role_id = roles.id WHERE user_id = ?', array($user['id']));
        $roles = array();
        while ($role = $rolesStmt->fetch(PDO::FETCH_ASSOC)) {
            $roles[] = $role['role'];
        }

        return new User($user['username'], $user['password'], explode(',', $user['roles']), true, true, true, true);
    }

    public function refreshUser(UserInterface $user)
    {
        if (!$user instanceof User) {
            throw new UnsupportedUserException(sprintf('Instances of "%s" are not supported.', get_class($user)));
        }

        return $user;
    }

    public function supportsClass($class)
    {
        return $class === 'SymfonyComponentSecurityCoreUserUser';
    }
}

Dans le code ci-dessus, la méthode loadUserByUsername est utilisée pour interroger les informations utilisateur en fonction du nom d'utilisateur, et en même temps interroger les rôles (rôles),freshUser et supportsClass appartenant à l'utilisateur doivent être implémentés pour l'implémentation de l'interface.

5. Créer un contrôleur

Créer un contrôleur dans le framework Silex nécessite de définir une URL privée qui guide l'utilisateur vers la page de connexion pour l'authentification. Si l'authentification réussit, l'utilisateur sera activement redirigé vers l'URL demandée d'origine. Si l'authentification échoue, un message d'erreur sera affiché et la page de connexion s'affichera pour vous réauthentifier.

Ajoutez le code suivant dans app.php :

$app->match('/login', function(Request $request) use ($app){
        $username = $request->request->get('_username');
        $password = $request->request->get('_password');

        $user = $app['security.user_provider']->loadUserByUsername($username);

        if (!$app['security.encoder.bcrypt']->isPasswordValid($user->getPassword(), $password, $user->getSalt())) {
            throw new Exception('Bad credentials');
        } else {
            $token = new UsernamePasswordToken($user, null, 'secured', $user->getRoles());
            $app['security.token_storage']->setToken($token);
            $request->getSession()->set('_security_secured', serialize($token));
            return $app->redirect($request->headers->get('referer'));
        }
})->bind('login');

$app->match('/secured', function() use ($app){
        if (!$app['security.authorization_checker']->isGranted('ROLE_USER')){
            return $app->redirect('/login');
        }
 
        return 'Welcome ' . $app['security.token_storage']->getToken()->getUsername();
})->bind('secured');

Dans le code ci-dessus, la route /login est une URL privée, qui permet aux utilisateurs de soumettre des informations de nom d'utilisateur et de mot de passe pour authentification d'identité La route /secured est une route avec des droits d'accès restreints. Si l'utilisateur accède à la route /secured sans authentification, il sera redirigé vers la page de connexion.

6. Résumé

À travers les étapes ci-dessus, nous avons implémenté la fonction d'authentification de l'identité de l'utilisateur dans le framework Silex. Dans ce processus, nous avons utilisé le composant Symfony Security pour implémenter les fonctions d'authentification et de fournisseur d'utilisateurs. En même temps, les informations de configuration, les fournisseurs d'utilisateurs et le contrôleur doivent être configurés pour implémenter un système d'authentification complet. À travers l'introduction ci-dessus, j'espère donner quelques références aux développeurs qui doivent implémenter des fonctions d'authentification dans le framework Silex.

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!