PHP Auth
1.0.0
Authentification pour PHP. Simple, léger et sécurisé.
Écrit une fois, pour être utilisé partout.
Complètement indépendant du framework et de la base de données.
pdo )mysqlnd ) ou pilote PostgreSQL ( pgsql ) ou pilote SQLite ( sqlite )openssl )Incluez la bibliothèque via Composer [?] :
$ composer require delight-im/auth
Incluez le chargeur automatique Composer :
require __DIR__ . ' /vendor/autoload.php ' ;Configurez une base de données et créez les tables requises :
Vous migrez depuis une version antérieure de ce projet ? Consultez notre guide de mise à niveau pour obtenir de l'aide.
// $ db = new PDO ( ' mysql:dbname=my-database ; host = localhost ; charset = utf8mb4' , ' my-username' , ' my-password' ) ;
// or
// $ db = new PDO ( ' pgsql:dbname=my-database ; host = localhost ; port = 5432 ' , ' my-username' , ' my-password' ) ;
// or
// $ db = new PDO ( ' sqlite:../Databases/my-database.sqlite' ) ;
// or
// $ db = Delight D b P doDatabase::fromDsn ( new Delight D b P doDsn ( ' mysql:dbname=my-database ; host = localhost ; charset = utf8mb4' , ' my-username' , ' my-password' ) ) ;
// or
// $ db = Delight D b P doDatabase::fromDsn ( new Delight D b P doDsn ( ' pgsql:dbname=my-database ; host = localhost ; port = 5432 ' , ' my-username' , ' my-password' ) ) ;
// or
// $ db = Delight D b P doDatabase::fromDsn ( new Delight D b P doDsn ( ' sqlite:../Databases/my-database.sqlite' ) ) ;
$ auth = new Delight Auth Auth ( $ db ); Si vous disposez déjà d’une connexion PDO ouverte, réutilisez-la simplement. L'utilisateur de la base de données (par exemple my-username ) a besoin au moins des privilèges SELECT , INSERT , UPDATE et DELETE pour les tables utilisées par cette bibliothèque (ou leur base de données parent).
Si votre serveur Web se trouve derrière un serveur proxy et $_SERVER['REMOTE_ADDR'] ne contient que l'adresse IP du proxy, vous devez transmettre la véritable adresse IP de l'utilisateur au constructeur dans le deuxième argument, nommé $ipAddress . La valeur par défaut est l'adresse IP distante habituelle reçue par PHP.
Si vos tables de base de données pour cette bibliothèque ont besoin d'un préfixe commun, par exemple my_users au lieu de users (et de même pour les autres tables), transmettez le préfixe (par exemple my_ ) comme troisième paramètre au constructeur, nommé $dbTablePrefix . Ceci est facultatif et le préfixe est vide par défaut.
Pendant le développement, vous souhaiterez peut-être désactiver la limitation ou la limitation des requêtes effectuée par cette bibliothèque. Pour ce faire, transmettez false au constructeur comme quatrième argument, nommé $throttling . La fonctionnalité est activée par défaut.
Pendant la durée de vie d'une session, certaines données utilisateur peuvent être modifiées à distance, soit par un client dans une autre session, soit par un administrateur. Cela signifie que ces informations doivent être régulièrement resynchronisées avec leur source faisant autorité dans la base de données, ce que cette bibliothèque fait automatiquement. Par défaut, cela se produit toutes les cinq minutes. Si vous souhaitez modifier cet intervalle, transmettez un intervalle personnalisé en secondes au constructeur comme cinquième argument, nommé $sessionResyncInterval .
Si toutes vos tables de base de données nécessitent un nom de base de données commun, un nom de schéma ou un autre qualificatif qui doit être spécifié explicitement, vous pouvez éventuellement transmettre ce qualificatif au constructeur en tant que sixième paramètre, nommé $dbSchema .
Si vous souhaitez également utiliser une instance PdoDatabase (par exemple $db ) de manière indépendante, veuillez vous référer à la documentation de la bibliothèque de base de données.
try {
$ userId = $ auth -> register ( $ _POST [ ' email ' ], $ _POST [ ' password ' ], $ _POST [ ' username ' ], function ( $ selector , $ token ) {
echo ' Send ' . $ selector . ' and ' . $ token . ' to the user (e.g. via email) ' ;
echo ' For emails, consider using the mail(...) function, Symfony Mailer, Swiftmailer, PHPMailer, etc. ' ;
echo ' For SMS, consider using a third-party service and a compatible SDK ' ;
});
echo ' We have signed up a new user with the ID ' . $ userId ;
}
catch ( Delight Auth InvalidEmailException $ e ) {
die ( ' Invalid email address ' );
}
catch ( Delight Auth InvalidPasswordException $ e ) {
die ( ' Invalid password ' );
}
catch ( Delight Auth UserAlreadyExistsException $ e ) {
die ( ' User already exists ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' Too many requests ' );
} Remarque : La fonction de rappel anonyme est une fermeture. Ainsi, outre ses propres paramètres, seuls les superglobaux comme $_GET , $_POST , $_COOKIE et $_SERVER sont disponibles à l'intérieur. Pour toute autre variable de la portée parent, vous devez explicitement rendre une copie disponible à l'intérieur en ajoutant une clause use après la liste des paramètres.
Le nom d'utilisateur dans le troisième paramètre est facultatif. Vous pouvez y passer null si vous ne souhaitez pas gérer les noms d'utilisateur.
En revanche, si vous souhaitez appliquer des noms d'utilisateur uniques, appelez simplement registerWithUniqueUsername au lieu de register et soyez prêt à intercepter l' DuplicateUsernameException .
Remarque : Lors de l'acceptation et de la gestion des noms d'utilisateur, vous souhaiterez peut-être exclure les caractères de contrôle non imprimables et certains caractères spéciaux imprimables, comme dans la classe de caractères [x00-x1fx7f/:\] . Pour ce faire, vous pouvez encapsuler l'appel à Auth#register ou Auth#registerWithUniqueUsername dans une branche conditionnelle, par exemple en n'acceptant les noms d'utilisateur que lorsque la condition suivante est remplie :
if ( preg_match ( ' /[x00-x1fx7f/: \\ ]/ ' , $ username ) === 0 ) {
// ...
}Pour la vérification par e-mail, vous devez créer une URL avec le sélecteur et le jeton et l'envoyer à l'utilisateur, par exemple :
$ url = ' https://www.example.com/verify_email?selector= ' . urlencode ( $ selector ) . ' &token= ' . urlencode ( $ token ); Si vous ne souhaitez pas effectuer de vérification des e-mails, omettez simplement le dernier paramètre de Auth#register , c'est-à-dire la fonction anonyme ou la fermeture. Le nouvel utilisateur sera alors actif immédiatement.
Besoin de stocker des informations utilisateur supplémentaires ? Continuez à lire ici.
Remarque : lors de l'envoi d'un e-mail à l'utilisateur, veuillez noter que le nom d'utilisateur (facultatif), à ce stade, n'a pas encore été confirmé comme étant acceptable pour le propriétaire de la (nouvelle) adresse e-mail. Il peut contenir un langage offensant ou trompeur choisi par une personne qui n'est pas réellement le propriétaire de l'adresse.
try {
$ auth -> login ( $ _POST [ ' email ' ], $ _POST [ ' password ' ]);
echo ' User is logged in ' ;
}
catch ( Delight Auth InvalidEmailException $ e ) {
die ( ' Wrong email address ' );
}
catch ( Delight Auth InvalidPasswordException $ e ) {
die ( ' Wrong password ' );
}
catch ( Delight Auth EmailNotVerifiedException $ e ) {
die ( ' Email not verified ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' Too many requests ' );
} En revanche, si vous souhaitez vous connecter avec des noms d'utilisateur, soit en plus de la connexion via l'adresse e-mail, soit en remplacement, c'est également possible. Appelez simplement la méthode loginWithUsername au lieu de la méthode login . Ensuite, au lieu d’attraper InvalidEmailException , assurez-vous d’attraper à la fois UnknownUsernameException et AmbiguousUsernameException . Vous souhaiterez peut-être également lire les notes sur le caractère unique des noms d'utilisateur dans la section qui explique comment inscrire de nouveaux utilisateurs.
Extrayez le sélecteur et le jeton de l'URL sur laquelle l'utilisateur a cliqué dans l'e-mail de vérification.
try {
$ auth -> confirmEmail ( $ _GET [ ' selector ' ], $ _GET [ ' token ' ]);
echo ' Email address has been verified ' ;
}
catch ( Delight Auth InvalidSelectorTokenPairException $ e ) {
die ( ' Invalid token ' );
}
catch ( Delight Auth TokenExpiredException $ e ) {
die ( ' Token expired ' );
}
catch ( Delight Auth UserAlreadyExistsException $ e ) {
die ( ' Email address already exists ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' Too many requests ' );
} Si vous souhaitez que l'utilisateur soit automatiquement connecté après une confirmation réussie, appelez simplement confirmEmailAndSignIn au lieu de confirmEmail . Cette méthode alternative prend également en charge les connexions persistantes via son troisième paramètre facultatif.
En cas de succès, les deux méthodes confirmEmail et confirmEmailAndSignIn renvoient toutes deux un tableau avec la nouvelle adresse e-mail de l'utilisateur, qui vient d'être vérifiée, à l'index un. Si la confirmation concernait un changement d'adresse au lieu d'une simple vérification d'adresse, l'ancienne adresse e-mail de l'utilisateur sera incluse dans le tableau à l'index zéro.
Le troisième paramètre des méthodes Auth#login et Auth#confirmEmailAndSignIn contrôle si la connexion est persistante avec un cookie de longue durée. Avec une telle connexion persistante, les utilisateurs peuvent rester authentifiés pendant une longue période, même lorsque la session du navigateur est déjà fermée et que les cookies de session ont expiré. En règle générale, vous souhaiterez garder l'utilisateur connecté pendant des semaines ou des mois avec cette fonctionnalité, connue sous le nom de « se souvenir de moi » ou « me garder connecté ». De nombreux utilisateurs trouveront cela plus pratique, mais cela peut être moins sécurisé s'ils laissent leurs appareils sans surveillance.
if ( $ _POST [ ' remember ' ] == 1 ) {
// keep logged in for one year
$ rememberDuration = ( int ) ( 60 * 60 * 24 * 365.25 );
}
else {
// do not keep logged in after session ends
$ rememberDuration = null ;
}
// ...
$ auth -> login ( $ _POST [ ' email ' ], $ _POST [ ' password ' ], $ rememberDuration );
// . . . Sans la connexion persistante, qui est le comportement par défaut , un utilisateur ne restera connecté que jusqu'à ce qu'il ferme son navigateur, ou aussi longtemps qu'il est configuré via session.cookie_lifetime et session.gc_maxlifetime en PHP.
Omettez le troisième paramètre ou définissez-le sur null pour désactiver la fonctionnalité. Sinon, vous pouvez demander à l'utilisateur s'il souhaite activer « se souvenir de moi ». Cela se fait généralement avec une case à cocher dans votre interface utilisateur. Utilisez l'entrée de cette case à cocher pour décider ici entre null et une durée prédéfinie en secondes, par exemple 60 * 60 * 24 * 365.25 pour un an.
try {
$ auth -> forgotPassword ( $ _POST [ ' email ' ], function ( $ selector , $ token ) {
echo ' Send ' . $ selector . ' and ' . $ token . ' to the user (e.g. via email) ' ;
echo ' For emails, consider using the mail(...) function, Symfony Mailer, Swiftmailer, PHPMailer, etc. ' ;
echo ' For SMS, consider using a third-party service and a compatible SDK ' ;
});
echo ' Request has been generated ' ;
}
catch ( Delight Auth InvalidEmailException $ e ) {
die ( ' Invalid email address ' );
}
catch ( Delight Auth EmailNotVerifiedException $ e ) {
die ( ' Email not verified ' );
}
catch ( Delight Auth ResetDisabledException $ e ) {
die ( ' Password reset is disabled ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' Too many requests ' );
} Remarque : La fonction de rappel anonyme est une fermeture. Ainsi, outre ses propres paramètres, seuls les superglobaux comme $_GET , $_POST , $_COOKIE et $_SERVER sont disponibles à l'intérieur. Pour toute autre variable de la portée parent, vous devez explicitement rendre une copie disponible à l'intérieur en ajoutant une clause use après la liste des paramètres.
Vous devez créer une URL avec le sélecteur et le jeton et l'envoyer à l'utilisateur, par exemple :
$ url = ' https://www.example.com/reset_password?selector= ' . urlencode ( $ selector ) . ' &token= ' . urlencode ( $ token ); Si la durée de vie par défaut des demandes de réinitialisation de mot de passe ne fonctionne pas pour vous, vous pouvez utiliser le troisième paramètre de Auth#forgotPassword pour spécifier un intervalle personnalisé en secondes après lequel les demandes doivent expirer.
À l'étape suivante, les utilisateurs cliqueront sur le lien qu'ils ont reçu. Extrayez le sélecteur et le jeton de l'URL.
Si le couple sélecteur/jeton est valide, laissez l'utilisateur choisir un nouveau mot de passe :
try {
$ auth -> canResetPasswordOrThrow ( $ _GET [ ' selector ' ], $ _GET [ ' token ' ]);
echo ' Put the selector into a "hidden" field (or keep it in the URL) ' ;
echo ' Put the token into a "hidden" field (or keep it in the URL) ' ;
echo ' Ask the user for their new password ' ;
}
catch ( Delight Auth InvalidSelectorTokenPairException $ e ) {
die ( ' Invalid token ' );
}
catch ( Delight Auth TokenExpiredException $ e ) {
die ( ' Token expired ' );
}
catch ( Delight Auth ResetDisabledException $ e ) {
die ( ' Password reset is disabled ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' Too many requests ' );
}Alternativement, si vous n'avez pas besoin de messages d'erreur mais souhaitez uniquement vérifier la validité, vous pouvez utiliser la version légèrement plus simple :
if ( $ auth -> canResetPassword ( $ _GET [ ' selector ' ], $ _GET [ ' token ' ])) {
echo ' Put the selector into a "hidden" field (or keep it in the URL) ' ;
echo ' Put the token into a "hidden" field (or keep it in the URL) ' ;
echo ' Ask the user for their new password ' ;
}Désormais, lorsque vous disposez du nouveau mot de passe de l'utilisateur (et que vous disposez toujours des deux autres informations), vous pouvez réinitialiser le mot de passe :
try {
$ auth -> resetPassword ( $ _POST [ ' selector ' ], $ _POST [ ' token ' ], $ _POST [ ' password ' ]);
echo ' Password has been reset ' ;
}
catch ( Delight Auth InvalidSelectorTokenPairException $ e ) {
die ( ' Invalid token ' );
}
catch ( Delight Auth TokenExpiredException $ e ) {
die ( ' Token expired ' );
}
catch ( Delight Auth ResetDisabledException $ e ) {
die ( ' Password reset is disabled ' );
}
catch ( Delight Auth InvalidPasswordException $ e ) {
die ( ' Invalid password ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' Too many requests ' );
} Souhaitez-vous que l'utilisateur concerné se connecte automatiquement lorsque la réinitialisation de son mot de passe réussit ? Utilisez simplement Auth#resetPasswordAndSignIn au lieu de Auth#resetPassword pour connecter immédiatement l'utilisateur.
Si vous avez besoin de l'identifiant ou de l'adresse e-mail de l'utilisateur, par exemple pour lui envoyer une notification indiquant que son mot de passe a été réinitialisé avec succès, utilisez simplement la valeur de retour de Auth#resetPassword , qui est un tableau contenant deux entrées nommées id et email .
Si un utilisateur est actuellement connecté, il peut modifier son mot de passe.
try {
$ auth -> changePassword ( $ _POST [ ' oldPassword ' ], $ _POST [ ' newPassword ' ]);
echo ' Password has been changed ' ;
}
catch ( Delight Auth NotLoggedInException $ e ) {
die ( ' Not logged in ' );
}
catch ( Delight Auth InvalidPasswordException $ e ) {
die ( ' Invalid password(s) ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' Too many requests ' );
}Demander à l'utilisateur son mot de passe actuel (et bientôt ancien ) et l'exiger pour vérification est la méthode recommandée pour gérer les changements de mot de passe. Ceci est montré ci-dessus.
Si vous êtes sûr de ne pas avoir besoin de cette confirmation, vous pouvez appeler changePasswordWithoutOldPassword au lieu de changePassword et supprimer le premier paramètre de cet appel de méthode (qui autrement contiendrait l'ancien mot de passe).
Dans tous les cas, une fois le mot de passe de l'utilisateur modifié, vous devez envoyer un e-mail à l'adresse e-mail principale de son compte sous forme de notification hors bande informant le propriétaire du compte de ce changement critique.
Si un utilisateur est actuellement connecté, il peut modifier son adresse e-mail.
try {
if ( $ auth -> reconfirmPassword ( $ _POST [ ' password ' ])) {
$ auth -> changeEmail ( $ _POST [ ' newEmail ' ], function ( $ selector , $ token ) {
echo ' Send ' . $ selector . ' and ' . $ token . ' to the user (e.g. via email to the *new* address) ' ;
echo ' For emails, consider using the mail(...) function, Symfony Mailer, Swiftmailer, PHPMailer, etc. ' ;
echo ' For SMS, consider using a third-party service and a compatible SDK ' ;
});
echo ' The change will take effect as soon as the new email address has been confirmed ' ;
}
else {
echo ' We can ' t say if the user is who they claim to be ' ;
}
}
catch ( Delight Auth InvalidEmailException $ e ) {
die ( ' Invalid email address ' );
}
catch ( Delight Auth UserAlreadyExistsException $ e ) {
die ( ' Email address already exists ' );
}
catch ( Delight Auth EmailNotVerifiedException $ e ) {
die ( ' Account not verified ' );
}
catch ( Delight Auth NotLoggedInException $ e ) {
die ( ' Not logged in ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' Too many requests ' );
} Remarque : La fonction de rappel anonyme est une fermeture. Ainsi, outre ses propres paramètres, seuls les superglobaux comme $_GET , $_POST , $_COOKIE et $_SERVER sont disponibles à l'intérieur. Pour toute autre variable de la portée parent, vous devez explicitement rendre une copie disponible à l'intérieur en ajoutant une clause use après la liste des paramètres.
Pour la vérification par e-mail, vous devez créer une URL avec le sélecteur et le jeton et l'envoyer à l'utilisateur, par exemple :
$ url = ' https://www.example.com/verify_email?selector= ' . urlencode ( $ selector ) . ' &token= ' . urlencode ( $ token );Remarque : lors de l'envoi d'un e-mail à l'utilisateur, veuillez noter que le nom d'utilisateur (facultatif), à ce stade, n'a pas encore été confirmé comme étant acceptable pour le propriétaire de la (nouvelle) adresse e-mail. Il peut contenir un langage offensant ou trompeur choisi par une personne qui n'est pas réellement le propriétaire de l'adresse.
Une fois la demande de modification de l'adresse e-mail effectuée, ou mieux encore, une fois la modification confirmée par l'utilisateur, vous devez envoyer un e-mail à l'adresse e-mail précédente de son compte sous forme de notification hors bande informant le propriétaire du compte de ce changement critique.
Remarque : Les modifications apportées à l'adresse e-mail d'un utilisateur prennent effet immédiatement dans la session locale, comme prévu. Dans d'autres sessions (par exemple sur d'autres appareils), les modifications peuvent toutefois prendre jusqu'à cinq minutes pour prendre effet. Cela augmente les performances et ne pose généralement aucun problème. Si vous souhaitez néanmoins modifier ce comportement, diminuez simplement (ou peut-être augmentez) la valeur que vous transmettez au constructeur Auth comme argument nommé $sessionResyncInterval .
Si une demande de confirmation antérieure n'a pas pu être transmise à l'utilisateur, ou si l'utilisateur a manqué cette demande, ou s'il ne veut tout simplement pas attendre plus longtemps, vous pouvez renvoyer une demande antérieure comme ceci :
try {
$ auth -> resendConfirmationForEmail ( $ _POST [ ' email ' ], function ( $ selector , $ token ) {
echo ' Send ' . $ selector . ' and ' . $ token . ' to the user (e.g. via email) ' ;
echo ' For emails, consider using the mail(...) function, Symfony Mailer, Swiftmailer, PHPMailer, etc. ' ;
echo ' For SMS, consider using a third-party service and a compatible SDK ' ;
});
echo ' The user may now respond to the confirmation request (usually by clicking a link) ' ;
}
catch ( Delight Auth ConfirmationRequestNotFound $ e ) {
die ( ' No earlier request found that could be re-sent ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' There have been too many requests -- try again later ' );
}Si vous souhaitez spécifier l'utilisateur par son identifiant plutôt que par son adresse e-mail, cela est également possible :
try {
$ auth -> resendConfirmationForUserId ( $ _POST [ ' userId ' ], function ( $ selector , $ token ) {
echo ' Send ' . $ selector . ' and ' . $ token . ' to the user (e.g. via email) ' ;
echo ' For emails, consider using the mail(...) function, Symfony Mailer, Swiftmailer, PHPMailer, etc. ' ;
echo ' For SMS, consider using a third-party service and a compatible SDK ' ;
});
echo ' The user may now respond to the confirmation request (usually by clicking a link) ' ;
}
catch ( Delight Auth ConfirmationRequestNotFound $ e ) {
die ( ' No earlier request found that could be re-sent ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' There have been too many requests -- try again later ' );
} Remarque : La fonction de rappel anonyme est une fermeture. Ainsi, outre ses propres paramètres, seuls les superglobaux comme $_GET , $_POST , $_COOKIE et $_SERVER sont disponibles à l'intérieur. Pour toute autre variable de la portée parent, vous devez explicitement rendre une copie disponible à l'intérieur en ajoutant une clause use après la liste des paramètres.
Habituellement, vous devez créer une URL avec le sélecteur et le jeton et l'envoyer à l'utilisateur, par exemple comme suit :
$ url = ' https://www.example.com/verify_email?selector= ' . urlencode ( $ selector ) . ' &token= ' . urlencode ( $ token );Remarque : lors de l'envoi d'un e-mail à l'utilisateur, veuillez noter que le nom d'utilisateur (facultatif), à ce stade, n'a pas encore été confirmé comme étant acceptable pour le propriétaire de la (nouvelle) adresse e-mail. Il peut contenir un langage offensant ou trompeur choisi par une personne qui n'est pas réellement le propriétaire de l'adresse.
$ auth -> logOut ();
// or
try {
$ auth -> logOutEverywhereElse ();
}
catch ( Delight Auth NotLoggedInException $ e ) {
die ( ' Not logged in ' );
}
// or
try {
$ auth -> logOutEverywhere ();
}
catch ( Delight Auth NotLoggedInException $ e ) {
die ( ' Not logged in ' );
}De plus, si vous stockez également des informations personnalisées dans la session et si vous souhaitez que ces informations soient supprimées, vous pouvez détruire l'intégralité de la session en appelant une deuxième méthode :
$ auth -> destroySession (); Remarque : Les déconnexions globales prennent effet immédiatement dans la session locale, comme prévu. Dans d'autres sessions (par exemple sur d'autres appareils), les modifications peuvent toutefois prendre jusqu'à cinq minutes pour prendre effet. Cela augmente les performances et ne pose généralement aucun problème. Si vous souhaitez néanmoins modifier ce comportement, diminuez simplement (ou peut-être augmentez) la valeur que vous transmettez au constructeur Auth comme argument nommé $sessionResyncInterval .
if ( $ auth -> isLoggedIn ()) {
echo ' User is signed in ' ;
}
else {
echo ' User is not signed in yet ' ;
} Un raccourci/alias pour cette méthode est $auth->check() .
$ id = $ auth -> getUserId (); Si l'utilisateur n'est pas actuellement connecté, cela renvoie null .
Un raccourci/alias pour cette méthode est $auth->id() .
$ email = $ auth -> getEmail (); Si l'utilisateur n'est pas actuellement connecté, cela renvoie null .
$ username = $ auth -> getUsername ();N'oubliez pas que les noms d'utilisateur sont facultatifs et qu'il n'y a un nom d'utilisateur que si vous l'avez fourni lors de l'inscription.
Si l'utilisateur n'est pas actuellement connecté, cela renvoie null .
if ( $ auth -> isNormal ()) {
echo ' User is in default state ' ;
}
if ( $ auth -> isArchived ()) {
echo ' User has been archived ' ;
}
if ( $ auth -> isBanned ()) {
echo ' User has been banned ' ;
}
if ( $ auth -> isLocked ()) {
echo ' User has been locked ' ;
}
if ( $ auth -> isPendingReview ()) {
echo ' User is pending review ' ;
}
if ( $ auth -> isSuspended ()) {
echo ' User has been suspended ' ;
} if ( $ auth -> isRemembered ()) {
echo ' User did not sign in but was logged in through their long-lived cookie ' ;
}
else {
echo ' User signed in manually ' ;
} Si l'utilisateur n'est pas actuellement connecté, cela renvoie null .
$ ip = $ auth -> getIpAddress ();Afin de préserver l'adéquation de cette bibliothèque à toutes fins ainsi que sa réutilisation complète, elle n'est pas livrée avec des colonnes regroupées supplémentaires pour les informations utilisateur. Mais vous n'êtes bien sûr pas obligé de renoncer aux informations supplémentaires sur l'utilisateur :
Voici comment utiliser cette bibliothèque avec vos propres tables pour obtenir des informations utilisateur personnalisées de manière maintenable et réutilisable :
Ajoutez un nombre illimité de tables de base de données personnalisées dans lesquelles vous stockez des informations utilisateur personnalisées, par exemple une table nommée profiles .
Chaque fois que vous appelez la méthode register (qui renvoie l'ID du nouvel utilisateur), ajoutez ensuite votre propre logique qui remplit vos tables de base de données personnalisées.
Si vous n’avez que rarement besoin des informations utilisateur personnalisées, vous pouvez simplement les récupérer si nécessaire. Toutefois, si vous en avez besoin plus fréquemment, vous souhaiterez probablement l'avoir dans vos données de session. La méthode suivante vous permet de charger et d'accéder à vos données de manière fiable :
function getUserInfo ( Delight Auth Auth $ auth ) {
if (! $ auth -> isLoggedIn ()) {
return null ;
}
if (! isset ( $ _SESSION [ ' _internal_user_info ' ])) {
// TODO : load your custom user information and assign it to the session variable below
// $ _SESSION [ ' _internal_user_info' ] = ...
}
return $ _SESSION [ ' _internal_user_info ' ];
}Chaque fois que vous souhaitez confirmer à nouveau l'identité de l'utilisateur, par exemple avant que l'utilisateur ne soit autorisé à effectuer une action « dangereuse », vous devez vérifier à nouveau son mot de passe pour confirmer qu'il est bien celui qu'il prétend être.
Par exemple, lorsqu'un utilisateur a été mémorisé par un cookie de longue durée et que Auth#isRemembered renvoie donc true , cela signifie que l'utilisateur n'a probablement plus saisi son mot de passe depuis un certain temps. Dans ce cas, vous souhaiterez peut-être reconfirmer leur mot de passe.
try {
if ( $ auth -> reconfirmPassword ( $ _POST [ ' password ' ])) {
echo ' The user really seems to be who they claim to be ' ;
}
else {
echo ' We can ' t say if the user is who they claim to be ' ;
}
}
catch ( Delight Auth NotLoggedInException $ e ) {
die ( ' The user is not signed in ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' Too many requests ' );
}Chaque utilisateur peut avoir un certain nombre de rôles, que vous pouvez utiliser pour mettre en œuvre l'autorisation et affiner vos contrôles d'accès.
Les utilisateurs peuvent n'avoir aucun rôle (ce qu'ils ont par défaut), exactement un rôle ou toute combinaison arbitraire de rôles.
if ( $ auth -> hasRole ( Delight Auth Role:: SUPER_MODERATOR )) {
echo ' The user is a super moderator ' ;
}
// or
if ( $ auth -> hasAnyRole ( Delight Auth Role:: DEVELOPER , Delight Auth Role:: MANAGER )) {
echo ' The user is either a developer, or a manager, or both ' ;
}
// or
if ( $ auth -> hasAllRoles ( Delight Auth Role:: DEVELOPER , Delight Auth Role:: MANAGER )) {
echo ' The user is both a developer and a manager ' ;
} Alors que la méthode hasRole prend exactement un rôle comme argument, les deux méthodes hasAnyRole et hasAllRoles peuvent prendre n'importe quel nombre de rôles que vous souhaitez vérifier.
Alternativement, vous pouvez obtenir une liste de tous les rôles qui ont été attribués à l'utilisateur :
$ auth -> getRoles (); Delight Auth Role:: ADMIN ;
Delight Auth Role:: AUTHOR ;
Delight Auth Role:: COLLABORATOR ;
Delight Auth Role:: CONSULTANT ;
Delight Auth Role:: CONSUMER ;
Delight Auth Role:: CONTRIBUTOR ;
Delight Auth Role:: COORDINATOR ;
Delight Auth Role:: CREATOR ;
Delight Auth Role:: DEVELOPER ;
Delight Auth Role:: DIRECTOR ;
Delight Auth Role:: EDITOR ;
Delight Auth Role:: EMPLOYEE ;
Delight Auth Role:: MAINTAINER ;
Delight Auth Role:: MANAGER ;
Delight Auth Role:: MODERATOR ;
Delight Auth Role:: PUBLISHER ;
Delight Auth Role:: REVIEWER ;
Delight Auth Role:: SUBSCRIBER ;
Delight Auth Role:: SUPER_ADMIN ;
Delight Auth Role:: SUPER_EDITOR ;
Delight Auth Role:: SUPER_MODERATOR ;
Delight Auth Role:: TRANSLATOR ;Vous pouvez utiliser n’importe lequel de ces rôles et ignorer ceux dont vous n’avez pas besoin. La liste ci-dessus peut également être récupérée par programme, dans l'un des trois formats suivants :
Delight Auth Role:: getMap ();
// or
Delight Auth Role:: getNames ();
// or
Delight Auth Role:: getValues ();Les autorisations de chaque utilisateur sont codées de manière à ce que les exigences de rôle soient spécifiées dans votre base de code. Si ces exigences sont évaluées avec un ensemble de rôles d'utilisateur spécifique, les autorisations implicitement vérifiées en sont le résultat.
Pour les projets plus importants, il est souvent recommandé de conserver la définition des autorisations en un seul endroit. Ensuite, vous ne vérifiez pas les rôles dans votre logique métier, mais vous vérifiez les autorisations individuelles . Vous pouvez mettre en œuvre ce concept comme suit :
function canEditArticle ( Delight Auth Auth $ auth ) {
return $ auth -> hasAnyRole (
Delight Auth Role:: MODERATOR ,
Delight Auth Role:: SUPER_MODERATOR ,
Delight Auth Role:: ADMIN ,
Delight Auth Role:: SUPER_ADMIN
);
}
// . . .
if ( canEditArticle ( $ auth )) {
echo ' The user can edit articles here ' ;
}
// . . .
if ( canEditArticle ( $ auth )) {
echo ' ... and here ' ;
}
// . . .
if ( canEditArticle ( $ auth )) {
echo ' ... and here ' ;
}Comme vous pouvez le constater, l'autorisation permettant à un certain utilisateur de modifier un article est stockée dans un emplacement central. Cette implémentation présente deux avantages majeurs :
Si vous souhaitez savoir quels utilisateurs peuvent modifier des articles, vous n'avez pas besoin de vérifier votre logique métier à différents endroits, mais il vous suffit de regarder où l'autorisation spécifique est définie. Et si vous souhaitez changer qui peut modifier un article, vous ne devez le faire qu'à un seul endroit également, et non dans l'ensemble de votre base de code.
Mais cela entraîne également un peu plus de frais généraux lors de la première mise en œuvre des restrictions d'accès, ce qui peut en valoir la peine ou non pour votre projet.
Si les noms des rôles inclus ne fonctionnent pas pour vous, vous pouvez créer un alias pour un nombre illimité de rôles en utilisant vos propres identifiants, par exemple comme ceci :
namespace My Namespace ;
final class MyRole {
const CUSTOMER_SERVICE_AGENT = Delight Auth Role:: REVIEWER ;
const FINANCIAL_DIRECTOR = Delight Auth Role:: COORDINATOR ;
private function __construct () {}
}L'exemple ci-dessus vous permettrait d'utiliser
My Namespace MyRole:: CUSTOMER_SERVICE_AGENT ;
// and
My Namespace MyRole:: FINANCIAL_DIRECTOR ;au lieu de
Delight Auth Role:: REVIEWER ;
// and
Delight Auth Role:: COORDINATOR ;N'oubliez pas de ne pas alias un seul rôle inclus vers plusieurs rôles avec des noms personnalisés.
Bien que la réinitialisation du mot de passe par courrier électronique soit une fonctionnalité pratique que la plupart des utilisateurs trouvent utile de temps en temps, la disponibilité de cette fonctionnalité implique que les comptes de votre service sont aussi sécurisés que le compte de messagerie associé à l'utilisateur.
Vous pouvez offrir aux utilisateurs soucieux de leur sécurité (et expérimentés) la possibilité de désactiver la réinitialisation des mots de passe de leurs comptes (et de les réactiver ultérieurement) pour une sécurité renforcée :
try {
if ( $ auth -> reconfirmPassword ( $ _POST [ ' password ' ])) {
$ auth -> setPasswordResetEnabled ( $ _POST [ ' enabled ' ] == 1 );
echo ' The setting has been changed ' ;
}
else {
echo ' We can ' t say if the user is who they claim to be ' ;
}
}
catch ( Delight Auth NotLoggedInException $ e ) {
die ( ' The user is not signed in ' );
}
catch ( Delight Auth TooManyRequestsException $ e ) {
die ( ' Too many requests ' );
}Afin de vérifier la valeur actuelle de ce paramètre, utilisez la valeur de retour de
$ auth -> isPasswordResetEnabled ();pour l’option par défaut correcte dans votre interface utilisateur. Vous n'avez pas besoin de vérifier cette valeur pour les restrictions de la fonctionnalité, qui sont appliquées automatiquement.
Toutes les méthodes fournies par cette bibliothèque sont automatiquement protégées contre un nombre excessif de requêtes des clients. Si le besoin s'en fait sentir, vous pouvez (temporairement) désactiver cette protection à l'aide du paramètre $throttling passé au constructeur.
Si vous souhaitez également limiter ou limiter le débit des fonctionnalités ou méthodes externes , par exemple celles de votre propre code, vous pouvez utiliser la méthode d'assistance intégrée pour la limitation et la limitation du débit :
try {
// throttle the specified resource or feature to * 3 * requests per * 60 * seconds
$ auth -> throttle ([ ' my-resource-name ' ], 3 , 60 );
echo ' Do something with the resource or feature ' ;
}
catch ( Delight Auth TooManyRequestsException $ e ) {
// operation cancelled
http_response_code ( 429 );
exit ;
}Si la protection de la ressource ou de la fonctionnalité doit en outre dépendre d'un autre attribut, par exemple pour suivre quelque chose séparément par adresse IP, ajoutez simplement plus de données à la description de la ressource, telles que :
[ ' my-resource-name ' , $ _SERVER [ ' REMOTE_ADDR ' ] ]
// instead of
// [ ' my-resource-name' ] Il est possible d'autoriser de courtes périodes d'activité pendant les pics de demande en spécifiant un facteur de période de rafale comme quatrième argument. Une valeur de 5 , par exemple, permettrait des sursauts temporaires d'activité quintuple par rapport au niveau généralement accepté.
Dans certains cas, vous souhaiterez peut-être simplement simuler la limitation ou la limitation du débit. Cela vous permet de vérifier si une action serait autorisée sans modifier réellement le tracker d'activité. Pour ce faire, passez simplement true comme cinquième argument.
Remarque : Lorsque vous désactivez la limitation sur l'instance (à l'aide du paramètre $throttling transmis au constructeur), cela désactive à la fois la protection interne automatique et l'effet de tout appel à Auth#throttle dans votre propre code d'application – sauf si vous définissez également le Paramètre facultatif $force sur true dans les appels Auth#throttle spécifiques.
L'interface d'administration est disponible via $auth->admin() . Vous pouvez appeler diverses méthodes sur cette interface, comme documenté ci-dessous.
N'oubliez pas de mettre en œuvre un contrôle d'accès sécurisé avant d'exposer l'accès à cette interface. Par exemple, vous pouvez fournir l'accès à cette interface aux utilisateurs connectés avec le rôle d'administrateur uniquement, ou utiliser l'interface uniquement dans des scripts privés.
try {
$ userId = $ auth -> admin ()-> createUser ( $ _POST [ ' email ' ], $ _POST [ ' password ' ], $ _POST [ ' username ' ]);
echo ' We have signed up a new user with the ID ' . $ userId ;
}
catch ( Delight Auth InvalidEmailException $ e ) {
die ( ' Invalid email address ' );
}
catch ( Delight Auth InvalidPasswordException $ e ) {
die ( ' Invalid password ' );
}
catch ( Delight Auth UserAlreadyExistsException $ e ) {
die ( ' User already exists ' );
} Le nom d'utilisateur dans le troisième paramètre est facultatif. Vous pouvez y passer null si vous ne souhaitez pas gérer les noms d'utilisateur.
En revanche, si vous souhaitez appliquer des noms d'utilisateur uniques, appelez simplement createUserWithUniqueUsername au lieu de createUser et soyez prêt à intercepter l' DuplicateUsernameException .
Suppression d'utilisateurs par leur identifiant :
try {
$ auth -> admin ()-> deleteUserById ( $ _POST [ ' id ' ]);
}
catch ( Delight Auth UnknownIdException $ e ) {
die ( ' Unknown ID ' );
}Suppression d'utilisateurs par leur adresse e-mail :
try {
$ auth -> admin ()-> deleteUserByEmail ( $ _POST [ ' email ' ]);
}
catch ( Delight Auth InvalidEmailException $ e ) {
die ( ' Unknown email address ' );
}Suppression d'utilisateurs par leur nom d'utilisateur :
try {
$ auth -> admin ()-> deleteUserByUsername ( $ _POST [ ' username ' ]);
}
catch ( Delight Auth UnknownUsernameException $ e ) {
die ( ' Unknown username ' );
}
catch ( Delight Auth AmbiguousUsernameException $ e ) {
die ( ' Ambiguous username ' );
}Lors de la récupération d'une liste de tous les utilisateurs, les exigences varient considérablement selon les projets et les cas d'utilisation, et la personnalisation est courante. Par exemple, vous souhaiterez peut-être récupérer différentes colonnes, joindre des tables associées, filtrer selon certains critères, modifier la façon dont les résultats sont triés (dans différentes directions) et limiter le nombre de résultats (tout en fournissant un décalage).
C'est pourquoi il est plus facile d'utiliser une seule requête SQL personnalisée. Commencez par ce qui suit :
SELECT id, email, username, status, verified, roles_mask, registered, last_login FROM users; try {
$ auth -> admin ()-> addRoleForUserById ( $ userId , Delight Auth Role:: ADMIN );
}
catch ( Delight Auth UnknownIdException $ e ) {
die ( ' Unknown user ID ' );
}
// or
try {
$ auth -> admin ()-> addRoleForUserByEmail ( $ userEmail , Delight Auth Role:: ADMIN );
}
catch ( Delight Auth InvalidEmailException $ e ) {
die ( ' Unknown email address ' );
}
// or
try {
$ auth -> admin ()-> addRoleForUserByUsername ( $ username , Delight Auth Role:: ADMIN );
}
catch ( Delight Auth UnknownUsernameException $ e ) {
die ( ' Unknown username ' );
}
catch ( Delight Auth AmbiguousUsernameException $ e ) {
die ( ' Ambiguous username ' );
} Remarque : Les modifications apportées à l'ensemble des rôles d'un utilisateur peuvent prendre jusqu'à cinq minutes pour prendre effet. Cela augmente les performances et ne pose généralement aucun problème. Si vous souhaitez néanmoins modifier ce comportement, diminuez simplement (ou peut-être augmentez) la valeur que vous transmettez au constructeur Auth comme argument nommé $sessionResyncInterval .
try {
$ auth -> admin ()-> removeRoleForUserById ( $ userId , Delight Auth Role:: ADMIN );
}
catch ( Delight Auth UnknownIdException $ e ) {
die ( ' Unknown user ID ' );
}
// or
try {
$ auth -> admin ()-> removeRoleForUserByEmail ( $ userEmail , Delight Auth Role:: ADMIN );
}
catch ( Delight Auth InvalidEmailException $ e ) {
die ( ' Unknown email address ' );
}
// or
try {
$ auth -> admin ()-> removeRoleForUserByUsername ( $ username , Delight Auth Role:: ADMIN );
}
catch ( Delight Auth UnknownUsernameException $ e ) {
die ( ' Unknown username ' );
}
catch ( Delight Auth AmbiguousUsernameException $ e ) {
die ( ' Ambiguous username ' );
} Remarque : Les modifications apportées à l'ensemble des rôles d'un utilisateur peuvent prendre jusqu'à cinq minutes pour prendre effet. Cela augmente les performances et ne pose généralement aucun problème. Si vous souhaitez néanmoins modifier ce comportement, diminuez simplement (ou peut-être augmentez) la valeur que vous transmettez au constructeur Auth comme argument nommé $sessionResyncInterval .
try {
if ( $ auth -> admin ()-> doesUserHaveRole ( $ userId , Delight Auth Role:: ADMIN )) {
echo ' The specified user is an administrator ' ;
}
else {
echo ' The specified user is not an administrator ' ;
}
}
catch ( Delight Auth UnknownIdException $ e ) {
die ( ' Unknown user ID ' );
}Alternativement, vous pouvez obtenir une liste de tous les rôles qui ont été attribués à l'utilisateur :
$ auth -> admin ()-> getRolesForUserById ( $ userId ); try {
$ auth -> admin ()-> logInAsUserById ( $ _POST [ ' id ' ]);
}
catch ( Delight Auth UnknownIdException $ e ) {
die ( ' Unknown ID ' );
}
catch ( Delight Auth EmailNotVerifiedException $ e ) {
die ( ' Email address not verified ' );
}
// or
try {
$ auth -> admin ()-> logInAsUserByEmail ( $ _POST [ ' email ' ]);
}
catch ( Delight Auth InvalidEmailException $ e ) {
die ( ' Unknown email address ' );
}
catch ( Delight Auth EmailNotVerifiedException $ e ) {
die ( ' Email address not verified ' );
}
// or
try {
$ auth -> admin ()-> logInAsUserByUsername ( $ _POST [ ' username ' ]);
}
catch ( Delight Auth UnknownUsernameException $ e ) {
die ( ' Unknown username ' );
}
catch ( Delight Auth AmbiguousUsernameException $ e ) {
die ( ' Ambiguous username ' );
}
catch ( Delight Auth EmailNotVerifiedException $ e ) {
die ( ' Email address not verified ' );
} try {
$ auth -> admin ()-> changePasswordForUserById ( $ _POST [ ' id ' ], $ _POST [ ' newPassword ' ]);
}
catch ( Delight Auth UnknownIdException $ e ) {
die ( ' Unknown ID ' );
}
catch ( Delight Auth InvalidPasswordException $ e ) {
die ( ' Invalid password ' );
}
// or
try {
$ auth -> admin ()-> changePasswordForUserByUsername ( $ _POST [ ' username ' ], $ _POST [ ' newPassword ' ]);
}
catch ( Delight Auth UnknownUsernameException $ e ) {
die ( ' Unknown username ' );
}
catch ( Delight Auth AmbiguousUsernameException $ e ) {
die ( ' Ambiguous username ' );
}
catch ( Delight Auth InvalidPasswordException $ e ) {
die ( ' Invalid password ' );
}Cette bibliothèque utilise deux cookies pour conserver l'état du client : Le premier, dont vous pouvez récupérer le nom en utilisant
session_name ();est le cookie de session général (obligatoire). Le deuxième cookie (facultatif) n'est utilisé que pour les connexions persistantes et son nom peut être récupéré comme suit :
Delight Auth Auth:: createRememberCookieName ();Vous pouvez renommer le cookie de session utilisé par cette bibliothèque par l'un des moyens suivants, par ordre de recommandation :
Dans la configuration PHP ( php.ini ), recherchez la ligne avec la directive session.name et changez sa valeur en quelque chose comme session_v1 , comme dans :
session.name = session_v1
Le plus tôt possible dans votre application, et avant de créer l'instance Auth , appelez ini_set pour remplacer session.name par quelque chose comme session_v1 , comme dans :
ini_set ( ' session.name ' , ' session_v1 ' ); Pour que cela fonctionne, session.auto_start doit être défini sur 0 dans la configuration PHP ( php.ini ).
Le plus tôt possible dans votre application, et avant de créer l'instance Auth , appelez session_name avec un argument tel que session_v1 , comme dans :
session_name ( ' session_v1 ' ); Pour que cela fonctionne, session.auto_start doit être défini sur 0 dans la configuration PHP ( php.ini ).
Le nom du cookie pour les connexions persistantes changera également – automatiquement – suite à votre modification du nom du cookie de session.
L'attribut domain d'un cookie contrôle le domaine (et les sous-domaines) pour lequel le cookie sera valide, et donc l'endroit où la session et l'état d'authentification de l'utilisateur seront disponibles.
La valeur par défaut recommandée est une chaîne vide, ce qui signifie que le cookie ne sera valide que pour l'hôte actuel exact , à l'exclusion des sous-domaines pouvant exister. Vous ne devez utiliser une valeur différente que si vous devez partager des cookies entre différents sous-domaines. Souvent, vous souhaiterez partager des cookies entre le domaine nu et le sous-domaine www , mais vous souhaiterez peut-être également les partager entre tout autre ensemble de sous-domaines.
Quel que soit l'ensemble de sous-domaines que vous choisissez, vous devez définir l'attribut du cookie sur le nom de domaine le plus spécifique qui inclut toujours tous vos sous-domaines requis. Par exemple, pour partager des cookies entre example.com et www.example.com , vous devez définir l'attribut sur example.com . Mais si vous souhaitez partager des cookies entre sub1.app.example.com et sub2.app.example.com , vous devez définir l'attribut sur app.example.com . Tout nom de domaine explicitement spécifié inclura toujours tous les sous-domaines pouvant exister.
Vous pouvez modifier l'attribut de l'une des manières suivantes, par ordre de recommandation :
Dans la configuration PHP ( php.ini ), recherchez la ligne avec la directive session.cookie_domain et modifiez sa valeur comme vous le souhaitez, par exemple :
session.cookie_domain = example.com
Le plus tôt possible dans votre application, et avant de créer l'instance Auth , appelez ini_set pour modifier la valeur de la directive session.cookie_domain comme vous le souhaitez, par exemple :
ini_set ( ' session.cookie_domain ' , ' example.com ' ); Pour que cela fonctionne, session.auto_start doit être défini sur 0 dans la configuration PHP ( php.ini ).
L'attribut path d'un cookie contrôle les répertoires (et sous-répertoires) pour lesquels le cookie sera valide, et donc l'endroit où la session et l'état d'authentification de l'utilisateur seront disponibles.
Dans la plupart des cas, vous souhaiterez rendre les cookies disponibles pour tous les chemins, c'est-à-dire n'importe quel répertoire et fichier, en commençant par le répertoire racine. C'est ce que fait une valeur de / pour l'attribut, qui est également la valeur par défaut recommandée. Vous ne devez modifier cet attribut qu'avec une valeur différente, par exemple /path/to/subfolder , si vous souhaitez restreindre les répertoires dans lesquels vos cookies seront disponibles, par exemple pour héberger plusieurs applications côte à côte, dans différents répertoires, sous le même nom de domaine.
Vous pouvez modifier l'attribut de l'une des manières suivantes, par ordre de recommandation :
Dans la configuration PHP ( php.ini ), recherchez la ligne avec la directive session.cookie_path et modifiez sa valeur comme vous le souhaitez, par exemple :
session.cookie_path = /
Le plus tôt possible dans votre application, et avant de créer l'instance Auth , appelez ini_set pour modifier la valeur de la directive session.cookie_path comme vous le souhaitez, par exemple :
ini_set ( ' session.cookie_path ' , ' / ' ); Pour que cela fonctionne, session.auto_start doit être défini sur 0 dans la configuration PHP ( php.ini ).
En utilisant l'attribut httponly , vous pouvez contrôler si les scripts côté client, c'est-à-dire JavaScript, doivent pouvoir accéder ou non à vos cookies. Pour des raisons de sécurité, il est préférable de refuser l'accès des scripts à vos cookies, ce qui réduit les dégâts que pourraient causer, par exemple, des attaques XSS réussies contre votre application.
Ainsi, vous devez toujours définir httponly sur 1 , sauf dans les rares cas où vous avez vraiment besoin d'accéder à vos cookies depuis JavaScript et ne trouvez pas de meilleure solution. Dans ces cas, définissez l'attribut sur 0 , mais soyez conscient des conséquences.
Vous pouvez modifier l'attribut de l'une des manières suivantes, par ordre de recommandation :
Dans la configuration PHP ( php.ini ), recherchez la ligne avec la directive session.cookie_httponly et modifiez sa valeur comme vous le souhaitez, par exemple :
session.cookie_httponly = 1
Le plus tôt possible dans votre application, et avant de créer l'instance Auth , appelez ini_set pour modifier la valeur de la directive session.cookie_httponly comme vous le souhaitez, par exemple :
ini_set ( ' session.cookie_httponly ' , 1 ); Pour que cela fonctionne, session.auto_start doit être défini sur 0 dans la configuration PHP ( php.ini ).
À l'aide de l'attribut secure , vous pouvez contrôler si les cookies doivent être envoyés via n'importe quelle connexion, y compris HTTP simple, ou si une connexion sécurisée, c'est-à-dire HTTPS (avec SSL/TLS), doit être requise. Le premier mode (moins sécurisé) peut être choisi en définissant l'attribut sur 0 , et le second mode (plus sécurisé) peut être choisi en définissant l'attribut sur 1 .
Évidemment, cela dépend uniquement de votre capacité à diffuser toutes les pages exclusivement via HTTPS. Si vous le pouvez, vous devez définir l'attribut sur 1 et éventuellement le combiner avec des redirections HTTP vers le protocole sécurisé et HTTP Strict Transport Security (HSTS). Sinon, vous devrez peut-être conserver l'attribut défini sur 0 .
Vous pouvez modifier l'attribut de l'une des manières suivantes, par ordre de recommandation :
Dans la configuration PHP ( php.ini ), recherchez la ligne avec la directive session.cookie_secure et modifiez sa valeur comme vous le souhaitez, par exemple :
session.cookie_secure = 1
Le plus tôt possible dans votre application, et avant de créer l'instance Auth , appelez ini_set pour modifier la valeur de la directive session.cookie_secure comme vous le souhaitez, par exemple :
ini_set ( ' session.cookie_secure ' , 1 ); Pour que cela fonctionne, session.auto_start doit être défini sur 0 dans la configuration PHP ( php.ini ).
$ length = 24 ;
$ randomStr = Delight Auth Auth:: createRandomString ( $ length ); $ uuid = Delight Auth Auth:: createUuid ();Pour des informations détaillées sur la façon de lire et d'écrire facilement les données de session, veuillez vous référer à la documentation de la bibliothèque de session, qui est incluse par défaut.
Tout mot de passe ou jeton d'authentification est automatiquement haché à l'aide de la fonction « bcrypt », basée sur le chiffrement « Blowfish » et (encore) considérée comme l'une des fonctions de hachage de mot de passe les plus puissantes aujourd'hui. « bcrypt » est utilisé avec 1 024 itérations, soit un facteur « coût » de 10. Un « sel » aléatoire est également appliqué automatiquement.
Vous pouvez vérifier cette configuration en examinant les hachages dans la table de votre base de données users . Si ce qui précède est vrai avec votre configuration, tous les hachages de mots de passe dans votre table users doivent commencer par le préfixe $2$10$ , $2a$10$ ou $2y$10$ .
Lorsque de nouveaux algorithmes (tels que Argon2) pourraient être introduits à l'avenir, cette bibliothèque se chargera automatiquement de « mettre à niveau » vos hachages de mot de passe existants chaque fois qu'un utilisateur se connecte ou modifie son mot de passe.
Imposer une longueur minimale aux mots de passe est généralement une bonne idée. En dehors de cela, vous souhaiterez peut-être vérifier si un mot de passe potentiel se trouve dans une liste noire, que vous pourriez gérer dans une base de données ou dans un fichier, afin d'empêcher que des mots de dictionnaire ou des mots de passe couramment utilisés soient utilisés dans votre application.
Pour permettre une flexibilité et une facilité d'utilisation maximales, cette bibliothèque a été conçue de telle sorte qu'elle ne contient pas elle-même de vérifications supplémentaires des exigences de mot de passe, mais vous permet à la place d'envelopper vos propres vérifications autour des appels pertinents aux méthodes de la bibliothèque. Exemple:
function isPasswordAllowed ( $ password ) {
if ( strlen ( $ password ) < 8 ) {
return false ;
}
$ blacklist = [ ' password1 ' , ' 123456 ' , ' qwerty ' ];
if ( in_array ( $ password , $ blacklist )) {
return false ;
}
return true ;
}
if ( isPasswordAllowed ( $ password )) {
$ auth -> register ( $ email , $ password );
} Vous pouvez essayer de charger cette bibliothèque en premier et de créer d'abord l'instance Auth avant de charger les autres bibliothèques. À part cela, nous ne pouvons probablement pas faire grand-chose ici.
Si vous souhaitez permettre à d'autres d'inclure votre site dans un élément <frame> , <iframe> , <object> , <embed> ou <applet> , vous devez désactiver la prévention contre le détournement de clic par défaut :
header_remove ( ' X-Frame-Options ' );Cette bibliothèque génère deux types d'exceptions pour indiquer des problèmes :
AuthException et ses sous-classes sont levées chaque fois qu'une méthode ne se termine pas correctement. Vous devez toujours détecter ces exceptions car elles contiennent les réponses d'erreur normales auxquelles vous devez réagir.AuthError et ses sous-classes sont levées chaque fois qu'il y a un problème interne ou que la bibliothèque n'a pas été installée correctement. Vous ne devriez pas détecter ces exceptions. Toutes les contributions sont les bienvenues ! Si vous souhaitez contribuer, veuillez d'abord créer un problème afin que votre fonctionnalité, problème ou question puisse être discuté.
Ce projet est concédé sous licence de la licence du MIT.
