Cómo hacer la autenticación de usuario con el componente de seguridad de Symfony

() translation by (you can also view the original English article)

En este artículo, aprenderá a configurar la autenticación de usuario en PHP utilizando el componente Symfony Security. Además de la autenticación, le mostraré cómo usar su autorización basada en roles, que puede ampliar de acuerdo con sus necesidades.

El componente de seguridad de Symfony

El componente de seguridad de Symfony le permite configurar funciones de seguridad como la autenticación, la autorización basada en roles, los tokens CSRF y mucho más fácilmente. De hecho, está dividido en cuatro subcomponentes, que puede elegir de acuerdo con sus necesidades.

El componente de seguridad tiene los siguientes subcomponentes:

symfony/security-core
symfony/security-http
symfony/security-csrf
symfony/security-acl

En este artículo, vamos a explorar la función de autenticación proporcionada por el componente symfony / security-core.

Como de costumbre, comenzaremos con las instrucciones de instalación y configuración, y luego exploraremos algunos ejemplos del mundo real para demostrar los conceptos clave.

Instalacion y configuracion

En esta sección, vamos a instalar el componente de seguridad de Symfony. Supongo que ya ha instalado Composer en su sistema; lo necesitaremos para instalar el componente de seguridad disponible en Packagist.

Así que adelante e instale el componente de Seguridad usando el siguiente comando.

1	$composer require symfony/security

Vamos a cargar usuarios de la base de datos MySQL en nuestro ejemplo, por lo que también necesitaremos una capa de abstracción de la base de datos. Instalemos una de las capas de abstracción de base de datos más populares: Doctrine DBAL.

1	$composer require doctrine/dbal

Eso debería haber creado el archivo composer.json, que debería verse así:

{
    "require": {
        "symfony/security": "^4.1",
        "doctrine/dbal": "^2.7"
    }
}

Modifiquemos el archivo composer.json para que se vea como el siguiente.

{
    "require": {
        "symfony/security": "^4.1",
        "doctrine/dbal": "^2.7"
    },
    "autoload": {
         "psr-4": {
             "Sfauth\\": "src"
         },
         "classmap": ["src"]
    }
}

Como hemos agregado una nueva entrada de classmap, continuemos y actualicemos el autocargador del compositor ejecutando el siguiente comando.

1	$composer dump -o

Ahora puede usar el espacio de nombres de Sfauth para autocargar clases en el directorio src.

Esa es la parte de la instalación, pero ¿cómo se supone que debes usarla? De hecho, solo se trata de incluir el archivo autoload.php creado por Composer en su aplicación, como se muestra en el siguiente fragmento.

<?php
require_once './vendor/autoload.php';

// application code
?>

Un ejemplo del mundo real

En primer lugar, veamos el flujo de autenticación habitual proporcionado por el componente Symfony Security.

Lo primero es recuperar las credenciales del usuario y crear un token no autenticado.
A continuación, pasaremos un token no autenticado al administrador de autenticación para su validación.
El administrador de autenticación puede contener diferentes proveedores de autenticación, y uno de ellos se utilizará para autenticar la solicitud del usuario actual. La lógica de cómo se autentica el usuario se define en el proveedor de autenticación.
El proveedor de autenticación contacta al proveedor del usuario para recuperar al usuario. Es responsabilidad del proveedor del usuario cargar usuarios desde el back-end respectivo.
El proveedor de usuario intenta cargar al usuario utilizando las credenciales proporcionadas por el proveedor de autenticación. En la mayoría de los casos, el proveedor del usuario devuelve el objeto del usuario que implementa la interfaz UserInterface.
Si se encuentra el usuario, el proveedor de autenticación devuelve un token no autenticado y puede almacenar este token para las solicitudes posteriores.

En nuestro ejemplo, vamos a hacer coincidir las credenciales del usuario con la base de datos MySQL, por lo tanto, tendremos que crear el proveedor del usuario de la base de datos. También crearemos el proveedor de autenticación de base de datos que maneja la lógica de autenticación. Y finalmente, crearemos la clase User, que implementa la interfaz UserInterface.

La clase de usuario

En esta sección, crearemos la clase de usuario que representa la entidad de usuario en el proceso de autenticación.

Continúa y crea el archivo src / User / User.php con los siguientes contenidos.

<?php
namespace Sfauth\User;

use Symfony\Component\Security\Core\User\UserInterface;

class User implements UserInterface
{
    private $username;
    private $password;
    private $roles;

    public function __construct(string $username, string $password, string $roles)
    {
        if (empty($username))
        {
            throw new \InvalidArgumentException('No username provided.');
        }

        $this->username = $username;
        $this->password = $password;
        $this->roles = $roles;
    }

    public function getUsername()
    {
        return $this->username;
    }

    public function getPassword()
    {
        return $this->password;
    }

    public function getRoles()
    {
        return explode(",", $this->roles);
    }

    public function getSalt()
    {
        return '';
    }

    public function eraseCredentials() {}
}

Lo importante es que la clase User debe implementar la interfaz Symfony Security UserInterface. Aparte de eso, no hay nada fuera de lo común aquí.

La clase de proveedor de base de datos

Es responsabilidad del proveedor del usuario cargar usuarios desde el back-end. En esta sección, crearemos el proveedor de usuario de la base de datos, que carga al usuario desde la base de datos MySQL.

Vamos a crear el archivo src / User / DatabaseUserProvider.php con los siguientes contenidos.

<?php
namespace Sfauth\User;

use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
use Doctrine\DBAL\Connection;
use Sfauth\User\User;

class DatabaseUserProvider implements UserProviderInterface
{
    private $connection;

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

    public function loadUserByUsername($username)
    {
        return $this->getUser($username);
    }

    private function getUser($username)
    {
        $sql = "SELECT * FROM sf_users WHERE username = :name";
        $stmt = $this->connection->prepare($sql);
        $stmt->bindValue("name", $username);
        $stmt->execute();
        $row = $stmt->fetch();

        if (!$row['username'])
        {
            $exception = new UsernameNotFoundException(sprintf('Username "%s" not found in the database.', $row['username']));
            $exception->setUsername($username);
            throw $exception;
        }
        else
        {
            return new User($row['username'], $row['password'], $row['roles']);
        }
    }

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

        return $this->getUser($user->getUsername());
    }

    public function supportsClass($class)
    {
        return 'Sfauth\User\User' === $class;
    }
}

El proveedor del usuario debe implementar la interfaz UserProviderInterface. Estamos utilizando la doctrina DBAL para realizar las operaciones relacionadas con la base de datos. Como hemos implementado la interfaz UserProviderInterface, debemos implementar los métodos loadUserByUsername, refreshUser y supportsClass.

El método loadUserByUsername debe cargar al usuario por el nombre de usuario, y eso se hace en el método getUser. Si se encuentra el usuario, devolvemos el objeto Sfauth \ User \ User correspondiente, que implementa la interfaz UserInterface.

Por otro lado, el método refreshUser actualiza el objeto User suministrado obteniendo la última información de la base de datos.

Y finalmente, el método supportsClass comprueba si el proveedor DatabaseUserProvider es compatible con la clase de usuario suministrada.

La clase de proveedor de autenticación de base de datos

Finalmente, debemos implementar el proveedor de autenticación de usuario, que define la lógica de autenticación: cómo se autentica un usuario. En nuestro caso, tenemos que hacer coincidir las credenciales del usuario con la base de datos MySQL, y por lo tanto tenemos que definir la lógica de autenticación en consecuencia.

Continúa y crea el archivo src / User / DatabaseAuthenticationProvider.php con los siguientes contenidos.

<?php
namespace Sfauth\User;

use Symfony\Component\Security\Core\Authentication\Provider\UserAuthenticationProvider;
use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Core\User\UserCheckerInterface;
use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
use Symfony\Component\Security\Core\Exception\AuthenticationServiceException;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\Exception\AuthenticationException;

class DatabaseAuthenticationProvider extends UserAuthenticationProvider
{
    private $userProvider;

    public function __construct(UserProviderInterface $userProvider, UserCheckerInterface $userChecker, string $providerKey, bool $hideUserNotFoundExceptions = true)
    {
        parent::__construct($userChecker, $providerKey, $hideUserNotFoundExceptions);

        $this->userProvider = $userProvider;
    }

    protected function retrieveUser($username, UsernamePasswordToken $token)
    {
        $user = $token->getUser();

        if ($user instanceof UserInterface)
        {
            return $user;
        }

        try {
            $user = $this->userProvider->loadUserByUsername($username);

            if (!$user instanceof UserInterface)
            {
                throw new AuthenticationServiceException('The user provider must return a UserInterface object.');
            }

            return $user;
        } catch (UsernameNotFoundException $e) {
            $e->setUsername($username);

            throw $e;
        } catch (\Exception $e) {
            $e = new AuthenticationServiceException($e->getMessage(), 0, $e);
            $e->setToken($token);
            throw $e;
        }
    }

    protected function checkAuthentication(UserInterface $user, UsernamePasswordToken $token)
    {
        $currentUser = $token->getUser();
        
        if ($currentUser instanceof UserInterface)
        {
            if ($currentUser->getPassword() !== $user->getPassword())
            {
                throw new AuthenticationException('Credentials were changed from another session.');
            }
        }
        else
        {
            $password = $token->getCredentials();

            if (empty($password))
            {
                throw new AuthenticationException('Password can not be empty.');
            }

            if ($user->getPassword() != md5($password))
            {
                throw new AuthenticationException('Password is invalid.');
            }
        }
    }
}

El proveedor de autenticación DatabaseAuthenticationProvider amplía la clase abstracta UserAuthenticationProvider. Por lo tanto, debemos implementar los métodos abstractos retrieveUser y checkAuthentication.

El trabajo del método retrieveUser es cargar al usuario desde el proveedor de usuario correspondiente. En nuestro caso, utilizará el proveedor de usuario DatabaseUserProvider para cargar al usuario desde la base de datos MySQL.

Por otro lado, el método checkAuthentication realiza las comprobaciones necesarias para autenticar al usuario actual. Tenga en cuenta que he utilizado el método MD5 para el cifrado de contraseñas. Por supuesto, debe usar métodos de cifrado más seguros para almacenar las contraseñas de los usuarios.

Cómo funciona en conjunto

Hasta ahora, hemos creado todos los elementos necesarios para la autenticación. En esta sección, veremos cómo armar todo para configurar la funcionalidad de autenticación.

Continúe y cree el archivo db_auth.php y rellene con los siguientes contenidos.

<?php
require_once './vendor/autoload.php';

use Sfauth\User\DatabaseUserProvider;
use Symfony\Component\Security\Core\User\UserChecker;
use Sfauth\User\DatabaseAuthenticationProvider;
use Symfony\Component\Security\Core\Authentication\AuthenticationProviderManager;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Core\Exception\AuthenticationException;

// init doctrine db connection
$doctrineConnection = \Doctrine\DBAL\DriverManager::getConnection(
  array('url' => 'mysql://{USERNAME}:{PASSWORD}@{HOSTNAME}/{DATABASE_NAME}'), new \Doctrine\DBAL\Configuration()
);

// init our custom db user provider
$userProvider = new DatabaseUserProvider($doctrineConnection);

// we'll use default UserChecker, it's used to check additional checks like account lock/expired etc.
// you can implement your own by implementing UserCheckerInterface interface
$userChecker = new UserChecker();

// init our custom db authentication provider
$dbProvider = new DatabaseAuthenticationProvider(
    $userProvider,
    $userChecker,
    'frontend'
);

// init authentication provider manager
$authenticationManager = new AuthenticationProviderManager(array($dbProvider));

try {
    // init un/pw, usually you'll get these from the $_POST variable, submitted by the end user
    $username = 'admin';
    $password = 'admin';

    // get unauthenticated token
    $unauthenticatedToken = new UsernamePasswordToken(
        $username,
        $password,
        'frontend'
    );

    // authenticate user & get authenticated token
    $authenticatedToken = $authenticationManager->authenticate($unauthenticatedToken);

    // we have got the authenticated token (user is logged in now), it can be stored in a session for later use
    echo $authenticatedToken;
    echo "\n";
} catch (AuthenticationException $e) {
    echo $e->getMessage();
    echo "\n";
}

Recuerde el flujo de autenticación que se discutió al principio de este artículo: el código anterior refleja esa secuencia.

Lo primero fue recuperar las credenciales del usuario y crear un token no autenticado.

$unauthenticatedToken = new UsernamePasswordToken(
    $username,
    $password,
    'frontend'
);

A continuación, pasamos ese token al administrador de autenticación para su validación.

1	// authenticate user & get authenticated token
2	$authenticatedToken = $authenticationManager->authenticate($unauthenticatedToken);

Cuando se llama al método de autenticación, ocurren muchas cosas detrás de escena.

En primer lugar, el administrador de autenticación selecciona un proveedor de autenticación apropiado. En nuestro caso, es el proveedor de autenticación DatabaseAuthenticationProvider, que se seleccionará para la autenticación.

A continuación, recupera al usuario por el nombre de usuario del proveedor de usuario DatabaseUserProvider. Finalmente, el método checkAuthentication realiza las comprobaciones necesarias para autenticar la solicitud del usuario actual.

Si desea probar el script db_auth.php, deberá crear la tabla sf_users en su base de datos MySQL.

CREATE TABLE `sf_users` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) NOT NULL,
  `password` varchar(255) NOT NULL,
  `roles` enum('registered','moderator','admin') DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB;

INSERT INTO `sf_users` VALUES (1,'admin','21232f297a57a5a743894a0e4a801fc3','admin');

Continúa y ejecuta el script db_auth.php para ver cómo funciona. Tras completar con éxito, debe recibir un token autenticado, como se muestra en el siguiente fragmento.

1	$php db_auth.php
2	UsernamePasswordToken(user="admin", authenticated=true, roles="admin")

Una vez que el usuario está autenticado, puede almacenar el token autenticado en la sesión para las solicitudes posteriores.

¡Y con eso, hemos completado nuestra demostración de autenticación simple!

Conclusión

Hoy, miramos el componente Symfony Security, que le permite integrar funciones de seguridad en sus aplicaciones PHP. Específicamente, hablamos sobre la función de autenticación proporcionada por el subcomponente symfony / security-core, y le mostré un ejemplo de cómo esta funcionalidad puede implementarse en su propia aplicación.

¡Siéntete libre de publicar tus pensamientos usando el feed a continuación!

1	<?php
2	namespace Sfauth\User;
3
4	use Symfony\Component\Security\Core\Authentication\Provider\UserAuthenticationProvider;
5	use Symfony\Component\Security\Core\User\UserProviderInterface;
6	use Symfony\Component\Security\Core\User\UserCheckerInterface;
7	use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
8	use Symfony\Component\Security\Core\Exception\AuthenticationServiceException;
9	use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
10	use Symfony\Component\Security\Core\User\UserInterface;
11	use Symfony\Component\Security\Core\Exception\AuthenticationException;
12
13	class DatabaseAuthenticationProvider extends UserAuthenticationProvider
14	{
15	private $userProvider;
16
17	public function __construct(UserProviderInterface $userProvider, UserCheckerInterface $userChecker, string $providerKey, bool $hideUserNotFoundExceptions = true)
18	{
19	parent::__construct($userChecker, $providerKey, $hideUserNotFoundExceptions);
20
21	$this->userProvider = $userProvider;
22	}
23
24	protected function retrieveUser($username, UsernamePasswordToken $token)
25	{
26	$user = $token->getUser();
27
28	if ($user instanceof UserInterface)
29	{
30	return $user;
31	}
32
33	try {
34	$user = $this->userProvider->loadUserByUsername($username);
35
36	if (!$user instanceof UserInterface)
37	{
38	throw new AuthenticationServiceException('The user provider must return a UserInterface object.');
39	}
40
41	return $user;
42	} catch (UsernameNotFoundException $e) {
43	$e->setUsername($username);
44
45	throw $e;
46	} catch (\Exception $e) {
47	$e = new AuthenticationServiceException($e->getMessage(), 0, $e);
48	$e->setToken($token);
49	throw $e;
50	}
51	}
52
53	protected function checkAuthentication(UserInterface $user, UsernamePasswordToken $token)
54	{
55	$currentUser = $token->getUser();
56
57	if ($currentUser instanceof UserInterface)
58	{
59	if ($currentUser->getPassword() !== $user->getPassword())
60	{
61	throw new AuthenticationException('Credentials were changed from another session.');
62	}
63	}
64	else
65	{
66	$password = $token->getCredentials();
67
68	if (empty($password))
69	{
70	throw new AuthenticationException('Password can not be empty.');
71	}
72
73	if ($user->getPassword() != md5($password))
74	{
75	throw new AuthenticationException('Password is invalid.');
76	}
77	}
78	}
79	}