PHP Auth
1.0.0
Autenticación para PHP. Sencillo, ligero y seguro.
Escrito una vez, para ser utilizado en todas partes.
Completamente independiente del marco y de la base de datos.
pdo )mysqlnd ) o controlador PostgreSQL ( pgsql ) o controlador SQLite ( sqlite )openssl )Incluir la biblioteca a través de Composer [?]:
$ composer require delight-im/auth
Incluya el cargador automático Composer:
require __DIR__ . ' /vendor/autoload.php ' ;Configure una base de datos y cree las tablas necesarias:
¿Está migrando desde una versión anterior de este proyecto? Consulte nuestra guía de actualización para obtener ayuda.
// $ 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 ya tiene una conexión PDO abierta, simplemente reutilícela. El usuario de la base de datos (por ejemplo, my-username ) necesita al menos los privilegios SELECT , INSERT , UPDATE y DELETE para las tablas utilizadas por esta biblioteca (o su base de datos principal).
Si su servidor web está detrás de un servidor proxy y $_SERVER['REMOTE_ADDR'] solo contiene la dirección IP del proxy, debe pasar la dirección IP real del usuario al constructor en el segundo argumento, que se denomina $ipAddress . El valor predeterminado es la dirección IP remota habitual recibida por PHP.
Si las tablas de su base de datos para esta biblioteca necesitan un prefijo común, por ejemplo, my_users en lugar de users (y lo mismo para las otras tablas), pase el prefijo (por ejemplo, my_ ) como tercer parámetro al constructor, que se llama $dbTablePrefix . Esto es opcional y el prefijo está vacío de forma predeterminada.
Durante el desarrollo, es posible que desee desactivar la limitación o limitación de solicitudes que realiza esta biblioteca. Para hacerlo, pase false al constructor como cuarto argumento, que se denomina $throttling . La función está habilitada de forma predeterminada.
Durante la vida de una sesión, algunos datos del usuario pueden cambiarse de forma remota, ya sea por un cliente en otra sesión o por un administrador. Eso significa que esta información debe resincronizarse periódicamente con su fuente autorizada en la base de datos, lo que esta biblioteca hace automáticamente. De forma predeterminada, esto ocurre cada cinco minutos. Si desea cambiar este intervalo, pase un intervalo personalizado en segundos al constructor como quinto argumento, que se denomina $sessionResyncInterval .
Si todas las tablas de su base de datos necesitan un nombre de base de datos común, un nombre de esquema u otro calificador que deba especificarse explícitamente, opcionalmente puede pasar ese calificador al constructor como el sexto parámetro, que se denomina $dbSchema .
Si también desea utilizar una instancia PdoDatabase (por ejemplo, $db ) de forma independiente, consulte la documentación de la biblioteca de bases de datos.
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 ' );
} Nota: La función de devolución de llamada anónima es un cierre. Por lo tanto, además de sus propios parámetros, solo están disponibles en su interior parámetros superglobales como $_GET , $_POST , $_COOKIE y $_SERVER . Para cualquier otra variable del ámbito principal, debe hacer explícitamente una copia disponible dentro agregando una cláusula use después de la lista de parámetros.
El nombre de usuario en el tercer parámetro es opcional. Puede pasar null allí si no desea administrar nombres de usuarios.
Por otro lado, si desea imponer nombres de usuario únicos, simplemente llame registerWithUniqueUsername en lugar de register y prepárese para detectar DuplicateUsernameException .
Nota: Al aceptar y administrar nombres de usuario, es posible que desee excluir los caracteres de control que no se imprimen y ciertos caracteres especiales imprimibles, como en la clase de caracteres [x00-x1fx7f/:\] . Para hacerlo, puede ajustar la llamada a Auth#register o Auth#registerWithUniqueUsername dentro de una rama condicional, por ejemplo, aceptando solo nombres de usuario cuando se cumpla la siguiente condición:
if ( preg_match ( ' /[x00-x1fx7f/: \\ ]/ ' , $ username ) === 0 ) {
// ...
}Para la verificación por correo electrónico, debe crear una URL con el selector y el token y enviarla al usuario, por ejemplo:
$ url = ' https://www.example.com/verify_email?selector= ' . urlencode ( $ selector ) . ' &token= ' . urlencode ( $ token ); Si no desea realizar la verificación del correo electrónico, simplemente omita el último parámetro de Auth#register , es decir, la función anónima o cierre. Entonces, el nuevo usuario estará activo inmediatamente.
¿Necesita almacenar información adicional del usuario? Sigue leyendo aquí.
Nota: Al enviar un correo electrónico al usuario, tenga en cuenta que el nombre de usuario (opcional), en este momento, aún no ha sido confirmado como aceptable para el propietario de la (nueva) dirección de correo electrónico. Podría contener lenguaje ofensivo o engañoso elegido por alguien que en realidad no es el propietario de la dirección.
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 ' );
} Por otro lado, si desea iniciar sesión con nombres de usuario, ya sea además del inicio de sesión mediante dirección de correo electrónico o como reemplazo, también es posible. Simplemente llame al método loginWithUsername en lugar del método login . Luego, en lugar de detectar InvalidEmailException , asegúrese de detectar tanto UnknownUsernameException como AmbiguousUsernameException . Quizás también quieras leer las notas sobre la singularidad de los nombres de usuario en la sección que explica cómo registrar nuevos usuarios.
Extraiga el selector y el token de la URL en la que el usuario hizo clic en el correo electrónico de verificación.
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 desea que el usuario inicie sesión automáticamente después de una confirmación exitosa, simplemente llame confirmEmailAndSignIn en lugar de confirmEmail . Ese método alternativo también admite inicios de sesión persistentes a través de su tercer parámetro opcional.
En caso de éxito, los dos métodos confirmEmail y confirmEmailAndSignIn devuelven una matriz con la nueva dirección de correo electrónico del usuario, que acaba de ser verificada, en el índice uno. Si la confirmación fue para un cambio de dirección en lugar de una simple verificación de dirección, la dirección de correo electrónico anterior del usuario se incluirá en la matriz en el índice cero.
El tercer parámetro de los métodos Auth#login y Auth#confirmEmailAndSignIn controla si el inicio de sesión es persistente con una cookie de larga duración. Con un inicio de sesión tan persistente, los usuarios pueden permanecer autenticados durante mucho tiempo, incluso cuando la sesión del navegador ya se haya cerrado y las cookies de la sesión hayan caducado. Normalmente, querrás mantener al usuario conectado durante semanas o meses con esta función, que se conoce como "recordarme" o "mantenerme conectado". Muchos usuarios encontrarán esto más conveniente, pero puede resultar menos seguro si dejan sus dispositivos desatendidos.
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 );
// . . . Sin el inicio de sesión persistente, que es el comportamiento predeterminado , un usuario solo permanecerá conectado hasta que cierre su navegador, o mientras esté configurado a través de session.cookie_lifetime y session.gc_maxlifetime en PHP.
Omita el tercer parámetro o configúrelo en null para deshabilitar la función. De lo contrario, puede preguntarle al usuario si desea habilitar "recordarme". Esto generalmente se hace con una casilla de verificación en su interfaz de usuario. Utilice la entrada de esa casilla de verificación para decidir entre null y una duración predefinida en segundos aquí, por ejemplo, 60 * 60 * 24 * 365.25 por un año.
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 ' );
} Nota: La función de devolución de llamada anónima es un cierre. Por lo tanto, además de sus propios parámetros, solo están disponibles en su interior parámetros superglobales como $_GET , $_POST , $_COOKIE y $_SERVER . Para cualquier otra variable del ámbito principal, debe hacer explícitamente una copia disponible dentro agregando una cláusula use después de la lista de parámetros.
Debe crear una URL con el selector y el token y enviarla al usuario, por ejemplo:
$ url = ' https://www.example.com/reset_password?selector= ' . urlencode ( $ selector ) . ' &token= ' . urlencode ( $ token ); Si la duración predeterminada de las solicitudes de restablecimiento de contraseña no le funciona, puede usar el tercer parámetro de Auth#forgotPassword para especificar un intervalo personalizado en segundos después del cual las solicitudes deberían caducar.
Como siguiente paso, los usuarios harán clic en el enlace que recibieron. Extraiga el selector y el token de la URL.
Si el par selector/token es válido, permita que el usuario elija una nueva contraseña:
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 ' );
}Alternativamente, si no necesita ningún mensaje de error sino que sólo desea comprobar la validez, puede utilizar la versión un poco más sencilla:
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 ' ;
}Ahora, cuando tenga la nueva contraseña para el usuario (y aún tenga los otros dos datos), puede restablecer la contraseña:
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 ' );
} ¿Quiere que el usuario respectivo inicie sesión automáticamente cuando se restablezca correctamente su contraseña? Simplemente use Auth#resetPasswordAndSignIn en lugar de Auth#resetPassword para iniciar sesión como usuario inmediatamente.
Si necesita el ID del usuario o la dirección de correo electrónico, por ejemplo, para enviarle una notificación de que su contraseña se ha restablecido correctamente, simplemente utilice el valor de retorno de Auth#resetPassword , que es una matriz que contiene dos entradas denominadas id y email .
Si un usuario ha iniciado sesión actualmente, puede cambiar su contraseña.
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 ' );
}Pedirle al usuario su contraseña actual (y próximamente antigua ) y solicitarla para su verificación es la forma recomendada de manejar los cambios de contraseña. Esto se muestra arriba.
Sin embargo, si está seguro de que no necesita esa confirmación, puede llamar changePasswordWithoutOldPassword en lugar de changePassword y eliminar el primer parámetro de esa llamada al método (que de otro modo contendría la contraseña anterior).
En cualquier caso, después de que se haya cambiado la contraseña del usuario, debe enviar un correo electrónico a la dirección de correo electrónico principal de su cuenta como una notificación fuera de banda para informar al propietario de la cuenta sobre este cambio crítico.
Si un usuario ha iniciado sesión actualmente, puede cambiar su dirección de correo electrónico.
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 ' );
} Nota: La función de devolución de llamada anónima es un cierre. Por lo tanto, además de sus propios parámetros, solo están disponibles en su interior parámetros superglobales como $_GET , $_POST , $_COOKIE y $_SERVER . Para cualquier otra variable del ámbito principal, debe hacer explícitamente una copia disponible dentro agregando una cláusula use después de la lista de parámetros.
Para la verificación por correo electrónico, debe crear una URL con el selector y el token y enviarla al usuario, por ejemplo:
$ url = ' https://www.example.com/verify_email?selector= ' . urlencode ( $ selector ) . ' &token= ' . urlencode ( $ token );Nota: Al enviar un correo electrónico al usuario, tenga en cuenta que el nombre de usuario (opcional), en este momento, aún no ha sido confirmado como aceptable para el propietario de la (nueva) dirección de correo electrónico. Podría contener lenguaje ofensivo o engañoso elegido por alguien que en realidad no es el propietario de la dirección.
Después de que se haya realizado la solicitud para cambiar la dirección de correo electrónico, o mejor aún, después de que el usuario haya confirmado el cambio, debe enviar un correo electrónico a la dirección de correo electrónico anterior de su cuenta como una notificación fuera de banda informando al propietario de la cuenta sobre este cambio crítico.
Nota: Los cambios en la dirección de correo electrónico de un usuario entran en vigor en la sesión local inmediatamente, como se esperaba. Sin embargo, en otras sesiones (por ejemplo, en otros dispositivos), los cambios pueden tardar hasta cinco minutos en surtir efecto. Esto aumenta el rendimiento y normalmente no supone ningún problema. Sin embargo, si desea cambiar este comportamiento, simplemente disminuya (o quizás aumente) el valor que pasa al constructor Auth como argumento denominado $sessionResyncInterval .
Si no se pudo entregar al usuario una solicitud de confirmación anterior, o si el usuario no cumplió con esa solicitud, o si simplemente no quiere esperar más, puede volver a enviar una solicitud anterior como esta:
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 desea especificar el usuario por su ID en lugar de por su dirección de correo electrónico, también es posible:
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 ' );
} Nota: La función de devolución de llamada anónima es un cierre. Por lo tanto, además de sus propios parámetros, solo están disponibles en su interior parámetros superglobales como $_GET , $_POST , $_COOKIE y $_SERVER . Para cualquier otra variable del ámbito principal, debe hacer explícitamente una copia disponible dentro agregando una cláusula use después de la lista de parámetros.
Normalmente, deberías crear una URL con el selector y el token y enviarla al usuario, por ejemplo, de la siguiente manera:
$ url = ' https://www.example.com/verify_email?selector= ' . urlencode ( $ selector ) . ' &token= ' . urlencode ( $ token );Nota: Al enviar un correo electrónico al usuario, tenga en cuenta que el nombre de usuario (opcional), en este momento, aún no ha sido confirmado como aceptable para el propietario de la (nueva) dirección de correo electrónico. Podría contener lenguaje ofensivo o engañoso elegido por alguien que en realidad no es el propietario de la dirección.
$ 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 ' );
}Además, si también almacena información personalizada en la sesión y desea que esa información se elimine, puede destruir toda la sesión llamando a un segundo método:
$ auth -> destroySession (); Nota: Los cierres de sesión globales entran en vigor en la sesión local inmediatamente, como se esperaba. Sin embargo, en otras sesiones (por ejemplo, en otros dispositivos), los cambios pueden tardar hasta cinco minutos en surtir efecto. Esto aumenta el rendimiento y normalmente no supone ningún problema. Sin embargo, si desea cambiar este comportamiento, simplemente disminuya (o quizás aumente) el valor que pasa al constructor Auth como argumento denominado $sessionResyncInterval .
if ( $ auth -> isLoggedIn ()) {
echo ' User is signed in ' ;
}
else {
echo ' User is not signed in yet ' ;
} Una abreviatura/alias para este método es $auth->check() .
$ id = $ auth -> getUserId (); Si el usuario no ha iniciado sesión actualmente, esto devuelve null .
Una abreviatura/alias para este método es $auth->id() .
$ email = $ auth -> getEmail (); Si el usuario no ha iniciado sesión actualmente, esto devuelve null .
$ username = $ auth -> getUsername ();Recuerde que los nombres de usuario son opcionales y solo hay un nombre de usuario si lo proporcionó durante el registro.
Si el usuario no ha iniciado sesión actualmente, esto devuelve 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 el usuario no ha iniciado sesión actualmente, esto devuelve null .
$ ip = $ auth -> getIpAddress ();Para preservar la idoneidad de esta biblioteca para todos los propósitos, así como su total reutilización, no incluye columnas adicionales para información del usuario. Pero, por supuesto, no tiene por qué prescindir de información de usuario adicional:
A continuación se explica cómo utilizar esta biblioteca con sus propias tablas para obtener información personalizada del usuario de forma mantenible y reutilizable:
Agregue cualquier cantidad de tablas de bases de datos personalizadas donde almacene información de usuario personalizada, por ejemplo, una tabla llamada profiles .
Siempre que llame al método register (que devuelve la ID del nuevo usuario), agregue luego su propia lógica que llene las tablas de su base de datos personalizada.
Si necesita la información de usuario personalizada sólo en raras ocasiones, puede recuperarla según sea necesario. Sin embargo, si lo necesita con más frecuencia, probablemente desee tenerlo en los datos de su sesión. El siguiente método es cómo puede cargar y acceder a sus datos de manera confiable:
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 ' ];
}Siempre que desee volver a confirmar la identidad del usuario, por ejemplo, antes de que se le permita realizar alguna acción “peligrosa”, debe verificar su contraseña nuevamente para confirmar que realmente es quien dice ser.
Por ejemplo, cuando un usuario ha sido recordado por una cookie de larga duración y, por lo tanto, Auth#isRemembered devuelve true , esto significa que el usuario probablemente no haya ingresado su contraseña durante bastante tiempo. Es posible que desee volver a confirmar su contraseña en ese caso.
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 ' );
}Cada usuario puede tener cualquier número de roles, que puede utilizar para implementar la autorización y perfeccionar sus controles de acceso.
Los usuarios pueden no tener ningún rol (lo que tienen de forma predeterminada), tener exactamente un rol o cualquier combinación arbitraria de roles.
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 ' ;
} Si bien el método hasRole toma exactamente un rol como argumento, los dos métodos hasAnyRole y hasAllRoles pueden tomar cualquier número de roles que desees verificar.
Alternativamente, puede obtener una lista de todos los roles que se han asignado al usuario:
$ 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 ;Puede utilizar cualquiera de estos roles e ignorar aquellos que no necesita. La lista anterior también se puede recuperar mediante programación, en uno de tres formatos:
Delight Auth Role:: getMap ();
// or
Delight Auth Role:: getNames ();
// or
Delight Auth Role:: getValues ();Los permisos de cada usuario están codificados de la misma manera que los requisitos de función se especifican en todo el código base. Si esos requisitos se evalúan con el conjunto de roles de un usuario específico, el resultado son permisos verificados implícitamente.
Para proyectos más grandes, suele recomendarse mantener la definición de permisos en un único lugar. Luego no verifica los roles en su lógica de negocios, pero verifica los permisos individuales . Podrías implementar ese concepto de la siguiente manera:
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 ' ;
}Como puede ver, el permiso sobre si un determinado usuario puede editar un artículo se almacena en una ubicación central. Esta implementación tiene dos ventajas principales:
Si desea saber qué usuarios pueden editar artículos, no es necesario que verifique su lógica comercial en varios lugares, solo debe buscar dónde está definido el permiso específico. Y si desea cambiar quién puede editar un artículo, solo tiene que hacerlo en un solo lugar, no en todo el código base.
Pero esto también conlleva un poco más de gastos generales al implementar las restricciones de acceso por primera vez, lo que puede valer la pena o no para su proyecto.
Si los nombres de los roles incluidos no le funcionan, puede asignar un alias a cualquier número de roles usando sus propios identificadores, por ejemplo, así:
namespace My Namespace ;
final class MyRole {
const CUSTOMER_SERVICE_AGENT = Delight Auth Role:: REVIEWER ;
const FINANCIAL_DIRECTOR = Delight Auth Role:: COORDINATOR ;
private function __construct () {}
}El ejemplo anterior le permitiría utilizar
My Namespace MyRole:: CUSTOMER_SERVICE_AGENT ;
// and
My Namespace MyRole:: FINANCIAL_DIRECTOR ;en lugar de
Delight Auth Role:: REVIEWER ;
// and
Delight Auth Role:: COORDINATOR ;Solo recuerde no asignar un solo rol incluido a múltiples roles con nombres personalizados.
Si bien el restablecimiento de contraseña por correo electrónico es una función conveniente que la mayoría de los usuarios encuentran útil de vez en cuando, la disponibilidad de esta función implica que las cuentas de su servicio son tan seguras como la cuenta de correo electrónico asociada del usuario.
Puede brindar a los usuarios preocupados por la seguridad (y experimentados) la posibilidad de deshabilitar el restablecimiento de contraseñas para sus cuentas (y habilitarlos nuevamente más tarde) para mejorar la seguridad:
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 ' );
}Para verificar el valor actual de esta configuración, use el valor de retorno de
$ auth -> isPasswordResetEnabled ();para encontrar la opción predeterminada correcta en su interfaz de usuario. No es necesario verificar este valor para conocer las restricciones de la función, que se aplican automáticamente.
Todos los métodos proporcionados por esta biblioteca están protegidos automáticamente contra un número excesivo de solicitudes de los clientes. Si surge la necesidad, puede desactivar (temporalmente) esta protección utilizando el parámetro $throttling pasado al constructor.
Si también desea acelerar o limitar funciones o métodos externos , por ejemplo, los de su propio código, puede utilizar el método auxiliar integrado para acelerar y limitar la velocidad:
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 protección del recurso o característica depende adicionalmente de otro atributo, por ejemplo, para rastrear algo por separado por dirección IP, simplemente agregue más datos a la descripción del recurso, como por ejemplo:
[ ' my-resource-name ' , $ _SERVER [ ' REMOTE_ADDR ' ] ]
// instead of
// [ ' my-resource-name' ] Es posible permitir breves ráfagas de actividad durante los picos de demanda especificando un factor de ráfaga como cuarto argumento. Un valor de 5 , por ejemplo, permitiría estallidos temporales de actividad cinco veces mayor, en comparación con el nivel generalmente aceptado.
En algunos casos, es posible que desee simplemente simular la aceleración o la limitación de velocidad. Esto le permite comprobar si se permitiría una acción sin modificar realmente el rastreador de actividad. Para hacerlo, simplemente pase true como quinto argumento.
Nota: Cuando desactivas la limitación en la instancia (usando el parámetro $throttling pasado al constructor), esto desactiva tanto la protección interna automática como el efecto de cualquier llamada a Auth#throttle en tu propio código de aplicación, a menos que también configures la parámetro opcional $force en true en llamadas Auth#throttle específicas.
La interfaz administrativa está disponible a través de $auth->admin() . Puede llamar a varios métodos en esta interfaz, como se documenta a continuación.
No olvide implementar un control de acceso seguro antes de exponer el acceso a esta interfaz. Por ejemplo, puede proporcionar acceso a esta interfaz solo a usuarios registrados con el rol de administrador, o usar la interfaz solo en scripts privados.
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 ' );
} El nombre de usuario en el tercer parámetro es opcional. Puede pasar null allí si no desea administrar nombres de usuarios.
Por otro lado, si desea imponer nombres de usuario únicos, simplemente llame createUserWithUniqueUsername en lugar de createUser y prepárese para detectar DuplicateUsernameException .
Eliminar usuarios por su ID:
try {
$ auth -> admin ()-> deleteUserById ( $ _POST [ ' id ' ]);
}
catch ( Delight Auth UnknownIdException $ e ) {
die ( ' Unknown ID ' );
}Eliminar usuarios por su dirección de correo electrónico:
try {
$ auth -> admin ()-> deleteUserByEmail ( $ _POST [ ' email ' ]);
}
catch ( Delight Auth InvalidEmailException $ e ) {
die ( ' Unknown email address ' );
}Eliminar usuarios por su nombre de usuario:
try {
$ auth -> admin ()-> deleteUserByUsername ( $ _POST [ ' username ' ]);
}
catch ( Delight Auth UnknownUsernameException $ e ) {
die ( ' Unknown username ' );
}
catch ( Delight Auth AmbiguousUsernameException $ e ) {
die ( ' Ambiguous username ' );
}Al obtener una lista de todos los usuarios, los requisitos varían mucho entre proyectos y casos de uso, y la personalización es común. Por ejemplo, es posible que desee recuperar diferentes columnas, unir tablas relacionadas, filtrar según ciertos criterios, cambiar la forma en que se ordenan los resultados (en diferentes direcciones) y limitar la cantidad de resultados (al mismo tiempo que proporciona un desplazamiento).
Por eso es más fácil utilizar una única consulta SQL personalizada. Comience con lo siguiente:
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 ' );
} Nota: Los cambios en el conjunto de roles de un usuario pueden tardar hasta cinco minutos en surtir efecto. Esto aumenta el rendimiento y normalmente no supone ningún problema. Sin embargo, si desea cambiar este comportamiento, simplemente disminuya (o quizás aumente) el valor que pasa al constructor Auth como argumento denominado $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 ' );
} Nota: Los cambios en el conjunto de roles de un usuario pueden tardar hasta cinco minutos en surtir efecto. Esto aumenta el rendimiento y normalmente no supone ningún problema. Sin embargo, si desea cambiar este comportamiento, simplemente disminuya (o quizás aumente) el valor que pasa al constructor Auth como argumento denominado $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 ' );
}Alternativamente, puede obtener una lista de todos los roles que se han asignado al usuario:
$ 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 ' );
}Esta biblioteca utiliza dos cookies para mantener el estado del cliente: la primera, cuyo nombre puede recuperar usando
session_name ();es la cookie de sesión general (obligatoria). La segunda cookie (opcional) solo se utiliza para inicios de sesión persistentes y su nombre se puede recuperar de la siguiente manera:
Delight Auth Auth:: createRememberCookieName ();Puede cambiar el nombre de la cookie de sesión utilizada por esta biblioteca a través de uno de los siguientes medios, en orden de recomendación:
En la configuración de PHP ( php.ini ), busque la línea con la directiva session.name y cambie su valor a algo como session_v1 , como en:
session.name = session_v1
Lo antes posible en su aplicación, y antes de crear la instancia Auth , llame a ini_set para cambiar session.name a algo como session_v1 , como en:
ini_set ( ' session.name ' , ' session_v1 ' ); Para que esto funcione, session.auto_start debe establecerse en 0 en la configuración de PHP ( php.ini ).
Lo antes posible en su aplicación, y antes de crear la instancia Auth , llame session_name con un argumento como session_v1 , como en:
session_name ( ' session_v1 ' ); Para que esto funcione, session.auto_start debe establecerse en 0 en la configuración de PHP ( php.ini ).
El nombre de la cookie para inicios de sesión persistentes también cambiará, automáticamente, después de que cambie el nombre de la cookie de sesión.
El atributo domain de una cookie controla para qué dominio (y para qué subdominios) será válida la cookie y, por lo tanto, dónde estarán disponibles la sesión del usuario y el estado de autenticación.
El valor predeterminado recomendado es una cadena vacía, lo que significa que la cookie solo será válida para el host actual exacto , excluyendo cualquier subdominio que pueda existir. Solo debes usar un valor diferente si necesitas compartir cookies entre diferentes subdominios. A menudo, querrás compartir cookies entre el dominio simple y el subdominio www , pero es posible que también quieras compartirlas entre cualquier otro conjunto de subdominios.
Cualquiera que sea el conjunto de subdominios que elija, debe configurar el atributo de la cookie en el nombre de dominio más específico que aún incluya todos los subdominios requeridos. Por ejemplo, para compartir cookies entre example.com y www.example.com , establecería el atributo en example.com . Pero si desea compartir cookies entre sub1.app.example.com y sub2.app.example.com , debe establecer el atributo en app.example.com . Cualquier nombre de dominio especificado explícitamente siempre incluirá todos los subdominios que puedan existir.
Puede cambiar el atributo a través de uno de los siguientes medios, en orden de recomendación:
En la configuración de PHP ( php.ini ), busque la línea con la directiva session.cookie_domain y cambie su valor como desee, por ejemplo:
session.cookie_domain = example.com
Lo antes posible en su aplicación, y antes de crear la instancia Auth , llame a ini_set para cambiar el valor de la directiva session.cookie_domain como desee, por ejemplo:
ini_set ( ' session.cookie_domain ' , ' example.com ' ); Para que esto funcione, session.auto_start debe establecerse en 0 en la configuración de PHP ( php.ini ).
El atributo path de una cookie controla para qué directorios (y subdirectorios) será válida la cookie y, por lo tanto, dónde estarán disponibles la sesión del usuario y el estado de autenticación.
En la mayoría de los casos, querrás que las cookies estén disponibles para todas las rutas, es decir, cualquier directorio y archivo, comenzando en el directorio raíz. Eso es lo que hace un valor de / para el atributo, que también es el valor predeterminado recomendado. Sólo debe cambiar este atributo a un valor diferente, por ejemplo, /path/to/subfolder , si desea restringir en qué directorios estarán disponibles sus cookies, por ejemplo, para alojar múltiples aplicaciones una al lado de la otra, en diferentes directorios, bajo el mismo nombre de dominio.
Puede cambiar el atributo a través de uno de los siguientes medios, en orden de recomendación:
En la configuración de PHP ( php.ini ), busque la línea con la directiva session.cookie_path y cambie su valor como desee, por ejemplo:
session.cookie_path = /
Lo antes posible en su aplicación, y antes de crear la instancia Auth , llame a ini_set para cambiar el valor de la directiva session.cookie_path como desee, por ejemplo:
ini_set ( ' session.cookie_path ' , ' / ' ); Para que esto funcione, session.auto_start debe establecerse en 0 en la configuración de PHP ( php.ini ).
Usando el atributo httponly , puede controlar si los scripts del lado del cliente, es decir, JavaScript, deberían poder acceder a sus cookies o no. Por razones de seguridad, es mejor denegar el acceso de script a sus cookies, lo que reduce el daño que podrían causar, por ejemplo, ataques XSS exitosos contra su aplicación.
Por lo tanto, siempre debes configurar httponly en 1 , excepto en los raros casos en los que realmente necesitas acceder a tus cookies desde JavaScript y no puedes encontrar una solución mejor. En esos casos, establezca el atributo en 0 , pero tenga en cuenta las consecuencias.
Puede cambiar el atributo a través de uno de los siguientes medios, en orden de recomendación:
En la configuración de PHP ( php.ini ), busque la línea con la directiva session.cookie_httponly y cambie su valor como desee, por ejemplo:
session.cookie_httponly = 1
Lo antes posible en su aplicación, y antes de crear la instancia Auth , llame a ini_set para cambiar el valor de la directiva session.cookie_httponly como desee, por ejemplo:
ini_set ( ' session.cookie_httponly ' , 1 ); Para que esto funcione, session.auto_start debe establecerse en 0 en la configuración de PHP ( php.ini ).
Usando el atributo secure , puede controlar si las cookies deben enviarse a través de cualquier conexión, incluido HTTP simple, o si se debe requerir una conexión segura, es decir, HTTPS (con SSL/TLS). El primer modo (menos seguro) se puede elegir estableciendo el atributo en 0 y el último modo (más seguro) se puede elegir estableciendo el atributo en 1 .
Obviamente, esto depende únicamente de si puede servir todas las páginas exclusivamente a través de HTTPS. Si puede, debe establecer el atributo en 1 y posiblemente combinarlo con redirecciones HTTP al protocolo seguro y Seguridad de transporte estricta HTTP (HSTS). De lo contrario, es posible que deba mantener el atributo establecido en 0 .
Puede cambiar el atributo a través de uno de los siguientes medios, en orden de recomendación:
En la configuración de PHP ( php.ini ), busque la línea con la directiva session.cookie_secure y cambie su valor como desee, por ejemplo:
session.cookie_secure = 1
Lo antes posible en su aplicación, y antes de crear la instancia Auth , llame a ini_set para cambiar el valor de la directiva session.cookie_secure como desee, por ejemplo:
ini_set ( ' session.cookie_secure ' , 1 ); Para que esto funcione, session.auto_start debe establecerse en 0 en la configuración de PHP ( php.ini ).
$ length = 24 ;
$ randomStr = Delight Auth Auth:: createRandomString ( $ length ); $ uuid = Delight Auth Auth:: createUuid ();Para obtener información detallada sobre cómo leer y escribir datos de sesión cómodamente, consulte la documentación de la biblioteca de sesiones, que se incluye de forma predeterminada.
Cualquier contraseña o token de autenticación se procesa automáticamente mediante la función "bcrypt", que se basa en el cifrado "Blowfish" y (todavía) se considera una de las funciones de hash de contraseñas más potentes de la actualidad. "bcrypt" se utiliza con 1.024 iteraciones, es decir, un factor de "coste" de 10. También se aplica automáticamente una "sal" aleatoria.
Puede verificar esta configuración observando los hashes en la tabla de users de su base de datos. Si lo anterior es cierto con su configuración, todos los hash de contraseña en su tabla users deben comenzar con el prefijo $2$10$ , $2a$10$ o $2y$10$ .
Cuando se introduzcan nuevos algoritmos (como Argon2) en el futuro, esta biblioteca se encargará automáticamente de "actualizar" los hashes de contraseñas existentes cada vez que un usuario inicie sesión o cambie su contraseña.
Generalmente es una buena idea exigir una longitud mínima para las contraseñas. Aparte de eso, es posible que desees buscar si una posible contraseña se encuentra en alguna lista negra, que podrías administrar en una base de datos o en un archivo, para evitar que se utilicen palabras del diccionario o contraseñas de uso común en tu aplicación.
Para permitir la máxima flexibilidad y facilidad de uso, esta biblioteca ha sido diseñada para que no contenga ninguna verificación adicional de los requisitos de contraseña, sino que le permita ajustar sus propias comprobaciones en torno a las llamadas relevantes a los métodos de la biblioteca. Ejemplo:
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 );
} Puede intentar cargar esta biblioteca primero y crear la instancia Auth primero, antes de cargar las otras bibliotecas. Aparte de eso, probablemente no haya mucho que podamos hacer aquí.
Si desea permitir que otros incluyan su sitio en un elemento <frame> , <iframe> , <object> , <embed> o <applet> , debe desactivar la prevención de clickjacking predeterminada:
header_remove ( ' X-Frame-Options ' );Esta biblioteca genera dos tipos de excepciones para indicar problemas:
AuthException y sus subclases se lanzan cada vez que un método no se completa correctamente. Siempre debe detectar estas excepciones, ya que conllevan respuestas de error normales a las que debe reaccionar.AuthError y sus subclases se lanzan cada vez que hay un problema interno o la biblioteca no se ha instalado correctamente. No deberías detectar estas excepciones. ¡Todas las contribuciones son bienvenidas! Si desea contribuir, cree un problema primero para que se pueda discutir su función, problema o pregunta.
Este proyecto tiene licencia bajo los términos de la licencia MIT.
