Français
Français
La sécurité est cruciale lors du développement d'API. Pour garantir que seuls les utilisateurs autorisés peuvent accéder à des ressources spécifiques, nous utilisons généralement le mécanisme de jeton pour l'authentification et le contrôle de l'autorisation. En PHP, la fonction d'en-tête () est généralement utilisée pour envoyer des informations d'en-tête HTTP et peut être utilisée pour gérer la vérification des jetons. Cet article présentera comment utiliser la fonction d'en-tête () de PHP pour coopérer avec le jeton pour le contrôle de l'autorisation de l'API.
Le jeton est un diplôme de sécurité utilisé pour l'authentification et l'autorisation. Les types de jetons communs incluent JWT (jeton Web JSON) et OAuth Token. Les jetons sont généralement générés par le serveur après que l'utilisateur soit connecté et stocké par le client (par exemple dans le stockage local du navigateur ou en-tête de demande HTTP) pour l'authentification dans les demandes d'API suivantes.
Le processus de base de l'utilisation de jetons pour le contrôle d'autorisation de l'API est le suivant:
L'utilisateur envoie une demande à l'API et est livré avec un jeton.
Une fois que le serveur a reçu la demande, il utilise la fonction en-tête () pour lire le jeton dans l'en-tête de demande.
Le serveur vérifie la légitimité du jeton. Si la vérification passe, l'accès aux ressources pertinentes est autorisée; Si la vérification échoue, une réponse refusée est retournée.
Dans PHP, l'en-tête de demande HTTP peut être obtenu via la fonction $ _server ou getAllheders () . Supposons que nous voulons obtenir un jeton nommé autorisation de l'en-tête de demande, voici un exemple simple:
<?php
// ObtenirAuthorizationCelui dans la têteToken
function getAuthToken() {
if (isset($_SERVER['HTTP_AUTHORIZATION'])) {
return $_SERVER['HTTP_AUTHORIZATION'];
}
return null;
}
?>
La fonction getAuthToken () vérifie si l'en-tête d'autorisation existe et renvoie le jeton. S'il n'existe pas, retournez null .
Lors de la vérification d'un jeton, une vérification est généralement requise en fonction du contenu ou de la signature du jeton. Ici, nous supposons que pour utiliser JWT (jeton Web JSON) pour la vérification des jetons. Voici un processus de vérification simplifié:
<?php
// Analyser et vérifierJWT Token
function validateToken($token) {
$secret_key = "your-secret-key"; // Clé préréglable，Pour vérificationToken
// Un simple est utilisé iciJWTAnalyser et vérifier过程，En fait, des bibliothèques prêtes à l'emploi telles que Firebase JWT
// Voici un exemple simplifié
try {
// HypothèsesTokenLe format est "header.payload.signature"
$parts = explode('.', $token);
if (count($parts) !== 3) {
throw new Exception("TokenErreur dans le format");
}
// Vérification de la simulationToken（En application réelle, il peut être décryptéTokenEt vérifier la signature）
$payload = base64_decode($parts[1]);
$payload_data = json_decode($payload, true);
if (!$payload_data || !isset($payload_data['exp']) || $payload_data['exp'] < time()) {
throw new Exception("TokenExpiré");
}
// Tokenefficace
return true;
} catch (Exception $e) {
// Retour lorsqu'une erreur se produitfalse
return false;
}
}
?>
Dans le code ci-dessus, nous déterminons si le jeton est valide en démolissant le jeton JWT et en vérifiant la pièce de charge utile. Dans l'environnement de production réel, il est recommandé d'utiliser des bibliothèques JWT matures pour gérer la vérification des jetons.
Si la vérification du jeton échoue, nous pouvons utiliser la fonction d'en-tête () pour retourner le code d'état HTTP correspondant, tel que 401 (non autorisé) ou 403 (Access interdit). Par exemple:
<?php
// retour401Réponse non autorisée
function sendUnauthorizedResponse() {
header("HTTP/1.1 401 Unauthorized");
header("Content-Type: application/json");
echo json_encode(["error" => "Accès non autorisé，请提供efficace的Token"]);
exit();
}
?>
Lorsque la vérification du jeton échoue, nous appelons la fonction SendUnAuthorizedResponse () pour envoyer une réponse 401 non autorisée et fournir des informations d'erreur.
En combinant les fonctions précédentes, ce qui suit est un exemple complet montrant comment implémenter le contrôle d'autorisation de l'API dans PHP:
<?php
// ObtenirToken
$token = getAuthToken();
// Si ce n'est pas fourniToken，直接retour401Réponse non autorisée
if (!$token) {
sendUnauthorizedResponse();
}
// vérifierToken的efficace性
if (!validateToken($token)) {
sendUnauthorizedResponse();
}
// siTokenefficace，Continuer à traiterAPIdemander
echo json_encode(["message" => "APIdemander成功，权限vérifier通过"]);
?>
Dans cet exemple complet, obtenez d'abord le jeton dans la demande, et si le jeton est vide ou non valide, une réponse 401 non autorisée est retournée. Si le jeton est valide, la logique métier de l'API continue d'être exécutée.
Grâce à la fonction d'en-tête () de PHP combinée avec un jeton, nous pouvons facilement implémenter le contrôle d'autorisation de l'API. Le flux de travail de base comprend:
Extraire le jeton de l'en-tête de demande.
Vérifiez la validité du jeton.
Décidez d'autoriser l'accès à l'API en fonction des résultats de vérification.
Cette approche protège efficacement l'API, garantissant que seuls les utilisateurs autorisés peuvent accéder aux données ou ressources sensibles.
