Comment PHP implémente le mécanisme d'authentification et d'autorisation OAuth2.0 pour améliorer la sécurité des sites Web

OAuth2.0 est un protocole d'autorisation basé sur des jetons et constitue l'un des mécanismes d'authentification et d'autorisation les plus utilisés sur Internet. En simulant le processus d'autorisation des utilisateurs, il permet aux utilisateurs de partager leurs ressources avec des applications tierces sans fournir de noms d'utilisateur ni de mots de passe. PHP est un langage de script côté serveur largement utilisé dans le développement Web. Cet article explique comment utiliser PHP pour implémenter le mécanisme d'authentification et d'autorisation OAuth2.0 afin d'améliorer la sécurité du site Web.

Processus d'autorisation OAuth2.0

Le processus de base du mécanisme d'authentification et d'autorisation OAuth2.0 est le suivant :

1. L'utilisateur initie une demande d'autorisation auprès de l'application client.
2. L'application client initie une demande d'authentification auprès du serveur d'authentification OAuth2.0.
3. Le serveur d'authentification OAuth2.0 initie une demande d'authentification auprès de l'utilisateur et obtient l'autorisation de l'utilisateur.
4. L'utilisateur accepte d'autoriser et le serveur d'authentification fournit un jeton d'accès à l'application client.
5. Les applications clientes peuvent utiliser des jetons pour accéder aux ressources protégées sur le serveur d'authentification.

Avant de mettre en œuvre le mécanisme d'authentification et d'autorisation OAuth2.0, nous devons comprendre plusieurs concepts importants impliqués dans le protocole OAuth2.0 :

1. Propriétaire de la ressource : l'utilisateur qui possède la ressource.
2. Client : Application tierce, application qui a besoin d'accéder à des ressources.
3. Serveur d'authentification (serveur d'autorisation) : Un serveur chargé d'authentifier les identités des utilisateurs et d'autoriser les applications tierces à accéder aux ressources protégées.
4. Token : Un jeton utilisé pour accéder aux ressources protégées.

Comment implémenter OAuth2.0

Ensuite, nous présenterons comment utiliser PHP pour implémenter le mécanisme d'authentification et d'autorisation OAuth2.0 afin d'améliorer la sécurité du site Web. Le processus d'implémentation spécifique est le suivant :

1. Installer la bibliothèque PHP OAuth2.0

Nous pouvons utiliser Composer pour installer la bibliothèque PHP OAuth2.0. Entrez le répertoire du projet à partir de la ligne de commande et utilisez la commande suivante :

composer require bshaffer/oauth2-server-php

2. Créer un serveur d'authentification OAuth2.0

Afin de créer un serveur d'authentification OAuth2.0, nous devons définir les éléments suivants :

• Table utilisateur : utilisé pour stocker les informations et les informations d'identification de l'utilisateur (ici, nous utilisons MySQL pour stocker les informations de l'utilisateur).
• Tableau Client : enregistre toutes les demandes client enregistrées.
• Table des jetons : enregistre tous les jetons d'accès.
• Tableau de portée des jetons : enregistre les autorisations d'accès de tous les jetons.

Ici, nous prenons MySQL comme exemple. Vous pouvez utiliser l'instruction SQL suivante pour créer la table correspondante :

CREATE TABLE `users` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) NOT NULL,
  `password` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `oauth_clients` (
  `client_id` varchar(80) NOT NULL,
  `client_secret` varchar(80) NOT NULL,
  `redirect_uri` varchar(2000) NOT NULL,
  PRIMARY KEY (`client_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `oauth_access_tokens` (
  `access_token` varchar(40) NOT NULL,
  `client_id` varchar(80) NOT NULL,
  `user_id` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`access_token`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `oauth_refresh_tokens` (
  `access_token` varchar(40) NOT NULL,
  `client_id` varchar(80) NOT NULL,
  `user_id` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`access_token`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `oauth_scopes` (
  `scope` varchar(80) NOT NULL,
  `is_default` tinyint(1) DEFAULT NULL,
  PRIMARY KEY (`scope`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `oauth_jwt` (
  `client_id` varchar(80) NOT NULL,
  `subject` varchar(80) DEFAULT NULL,
  `public_key` varchar(2000) DEFAULT NULL,
  PRIMARY KEY (`client_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

3. Configurez le serveur d'authentification OAuth2.0

Ensuite, nous devons configurer le serveur d'authentification OAuth2.0. Nous devons définir les éléments suivants :

• Informations de connexion : informations de connexion au serveur, y compris la connexion à la base de données et le nom de la table de la base de données.
• Informations client : y compris l'identifiant client et la clé client.
• Informations de vérification : utilisées pour vérifier les informations de l'utilisateur et les informations du client.

Exemple de configuration :

$config = [
    'dsn' => 'mysql:dbname=oauth2;host=localhost',
    'username' => 'root',
    'password' => 'password',
    'auth_client_secret' => 'secret-key',
    'auth_user_table' => 'users',
    'auth_client_table' => 'oauth_clients',
    'auth_token_table' => 'oauth_access_tokens',
    'auth_scope_table' => 'oauth_scopes',
];

4. Créer un contrôleur OAuth2.0

Ensuite, nous devons créer un contrôleur OAuth2.0 pour gérer le processus d'authentification et d'autorisation d'OAuth2.0. Le contrôleur comprend principalement les méthodes suivantes :

• authorizeAction() : utilisée pour gérer les demandes d'autorisation.
• tokenAction() : utilisé pour gérer les demandes de jetons d'accès.
• refreshAction() : utilisé pour gérer les demandes de jetons d'actualisation.
• authenticate() : utilisé pour vérifier l'identité de l'utilisateur et l'identité du client.

Exemple de contrôleur :

use OAuth2StoragePdo;

class OAuth2Controller extends PhalconMvcController
{  
    public function authorizeAction()
    {
        // 创建此控制器的实例
        $server = $this->getOAuthServer();
        // 处理授权请求
        $response = new OAuth2HttpFoundationBridgeResponse();
        if (!$server->validateAuthorizeRequest(OAuth2HttpFoundationBridgeRequest::createFromGlobals(), $response)) {
            return $this->response->setContent(json_encode(['status' => 'fail', 'message' => '授权失败']));
        }
        if ($this->request->isPost()) {
            $is_authorized = (bool) $this->request->getPost('authorized', '');
            $server->handleAuthorizeRequest(OAuth2HttpFoundationBridgeRequest::createFromGlobals(), $response, $is_authorized);
            return $response;
        }
        // 显示授权页面
        return $this->view->render('oauth', 'authorize');
    }

    public function tokenAction()
    {
        // 创建此控制器的实例
        $server = $this->getOAuthServer();
        // 处理访问令牌请求
        $response = new OAuth2HttpFoundationBridgeResponse();
        $server->handleTokenRequest(OAuth2HttpFoundationBridgeRequest::createFromGlobals(), $response);
        return $response;
    }

    public function refreshAction()
    {
        // 创建此控制器的实例
        $server = $this->getOAuthServer();
        // 处理刷新令牌请求
        $response = new OAuth2HttpFoundationBridgeResponse();
        $server->handleTokenRequest(OAuth2HttpFoundationBridgeRequest::createFromGlobals(), $response);
        return $response;
    }

    protected function getOAuthServer()
    {
        // 获取连接信息
        $config = $this->config->OAuth2;
        $dsn = $config->dsn;
        $username = $config->username;
        $password = $config->password;
        $pdo = new PDO($dsn, $username, $password);
        $pdoStorage = new OAuth2StoragePdo($pdo, [
            'user_table' => $config->auth_user_table,
            'client_table' => $config->auth_client_table,
            'access_token_table' => $config->auth_token_table,
            'scope_table' => $config->auth_scope_table,
        ]);
        // 创建OAuth2.0服务器实例
        $server = new OAuth2Server($pdoStorage);
        // 配置客户端身份验证
        $server->addGrantType(new OAuth2GrantTypeClientCredentials($pdoStorage));
        // 配置用户身份验证
        $server->addGrantType(new OAuth2GrantTypeUserCredentials($pdoStorage));
        return $server;
    }
}

Conclusion

Cet article présente comment utiliser PHP pour implémenter le mécanisme d'authentification et d'autorisation OAuth2.0 afin d'améliorer la sécurité du site Web. Le mécanisme d'authentification et d'autorisation OAuth2.0 a été largement utilisé dans le domaine Internet et revêt une grande importance pour la sécurité des sites Web et des applications mobiles. L'utilisation du mécanisme d'authentification et d'autorisation OAuth2.0 peut offrir une sécurité accrue et une meilleure expérience utilisateur pour les sites Web et les applications mobiles.

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!