> Symfony 5 > Symfony 5 Seguridad: Autenticadores
Login to bookmark this video
Buy Access to Course
11.

Dar contraseñas a los usuarios

|

Share this awesome video!

|

Keep on Learning!

Start your All-Access Pass

With a Subscription, click any sentence in the script to jump to that part of the video!

Login Subscribe

A Symfony no le importa realmente si los usuarios de tu sistema tienen contraseñas o no. Si estás construyendo un sistema de inicio de sesión que lee las claves de la API desde una cabecera, entonces no hay contraseñas. Lo mismo ocurre si tienes algún tipo de sistema SSO. Tus usuarios pueden tener contraseñas... pero las introducen en algún otro sitio.

Pero para nosotros, sí queremos que cada usuario tenga una contraseña. Cuando usamos antes el comando make:user, en realidad nos preguntó si queríamos que nuestros usuarios tuvieran contraseñas. Respondimos que no... para poder hacer todo esto manualmente. Pero en un proyecto real, yo respondería que sí para ahorrar tiempo.

PasswordAuthenticatedUserInterface

Sabemos que todas las clases de usuario deben implementar UserInterface:

132 lines | src/Entity/User.php
// ... lines 1 - 7
use Symfony\Component\Security\Core\User\UserInterface;
// ... lines 9 - 12
class User implements UserInterface
{
// ... lines 15 - 130
}

Entonces, si necesitas comprobar las contraseñas de los usuarios en tu aplicación, también tienes que implementar una segunda interfaz llamada PasswordAuthenticatedUserInterface:

130 lines | src/Entity/User.php
// ... lines 1 - 6
use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
// ... lines 8 - 12
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
// ... lines 15 - 128
}

Esto requiere que tengas un nuevo método: getPassword().

Si estás usando Symfony 6, no tendrás esto todavía, así que añádelo:

132 lines | src/Entity/User.php
// ... lines 1 - 12
class User implements UserInterface
{
// ... lines 15 - 90
/**
* This method can be removed in Symfony 6.0 - is not needed for apps that do not check user passwords.
*
* @see PasswordAuthenticatedUserInterface
*/
public function getPassword(): ?string
{
return null;
}
// ... lines 100 - 130
}

Yo lo tengo porque estoy usando Symfony 5 y el método getPassword() es necesario por compatibilidad con el pasado: antes formaba parte de UserInterface.

Ahora que nuestros usuarios tendrán una contraseña, y que estamos implementandoPasswordAuthenticatedUserInterface, voy a eliminar este comentario sobre el método:

130 lines | src/Entity/User.php
// ... lines 1 - 12
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
// ... lines 15 - 90
/**
* @see PasswordAuthenticatedUserInterface
*/
public function getPassword(): ?string
{
return null;
}
// ... lines 98 - 128
}

Almacenamiento de una contraseña codificada para cada usuario

Bien, vamos a olvidarnos de la seguridad por un momento. En su lugar, céntrate en que necesitamos poder almacenar una contraseña única para cada usuario en la base de datos. Esto significa que nuestra entidad de usuario necesita un nuevo campo! Busca tu terminal y ejecuta:

symfony console make:entity

Actualicemos la entidad User, para añadir un nuevo campo llámalo password... que es una cadena, 255 de longitud es exagerado pero está bien... y luego di "no" a anulable. Pulsa enter para terminar.

De vuelta a la clase User, es... mayormente no sorprendente. Tenemos una nueva propiedad $password... y al final, un nuevo método setPassword():

142 lines | src/Entity/User.php
// ... lines 1 - 12
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
// ... lines 15 - 36
/**
* @ORM\Column(type="string", length=255)
*/
private $password;
// ... lines 41 - 134
public function setPassword(string $password): self
{
$this->password = $password;
return $this;
}
}

Fíjate que no ha generado un método getPassword()... porque ya teníamos uno. Pero tenemos que actualizarlo para que devuelva $this->password:

142 lines | src/Entity/User.php
// ... lines 1 - 12
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
// ... lines 15 - 98
public function getPassword(): ?string
{
return $this->password;
}
// ... lines 103 - 140
}

Algo muy importante sobre esta propiedad $password: no va a almacenar la contraseña en texto plano. ¡Nunca almacenes la contraseña en texto plano! Esa es la forma más rápida de tener una brecha de seguridad... y de perder amigos.

En su lugar, vamos a almacenar una versión cifrada de la contraseña... y veremos cómo generar esa contraseña cifrada en un minuto. Pero antes, vamos a hacer la migración para la nueva propiedad:

symfony console make:migration

Ve a echar un vistazo a ese archivo para asegurarte de que todo está bien:

32 lines | migrations/Version20211001185505.php
// ... lines 1 - 12
final class Version20211001185505 extends AbstractMigration
{
public function getDescription(): string
{
return '';
}
public function up(Schema $schema): void
{
// this up() migration is auto-generated, please modify it to your needs
$this->addSql('ALTER TABLE user ADD password VARCHAR(255) NOT NULL');
}
public function down(Schema $schema): void
{
// this down() migration is auto-generated, please modify it to your needs
$this->addSql('ALTER TABLE user DROP password');
}
}

Tip

Si utilizas PostgreSQL, deberás modificar tu migración. Añade DEFAULT '' al final para que la nueva columna pueda añadirse sin que se produzca un error`terminal $this->addSql('ALTER TABLE product ADD description VARCHAR(255) NOT NULL DEFAULT \'\'');

Y... ¡lo hace! Ciérralo... y ejecútalo:

symfony console doctrine:migrations:migrate

La configuración de password_hashers

¡Perfecto! Ahora que nuestros usuarios tienen una nueva columna de contraseña en la base de datos, vamos a rellenarla en nuestros accesorios. Abre src/Factory/UserFactory.php y busca getDefaults().

De nuevo, lo que no vamos a hacer es poner en password la contraseña en texto plano. No, esa propiedad password tiene que almacenar la versión hash de la contraseña.

Abre config/packages/security.yaml. Este tiene un poco de configuración en la parte superior llamada password_hashers, que le dice a Symfony qué algoritmo de hash debe utilizar para el hash de las contraseñas de los usuarios:

39 lines | config/packages/security.yaml
security:
// ... lines 2 - 6
# https://symfony.com/doc/current/security.html#c-hashing-passwords
password_hashers:
Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface: 'auto'
// ... lines 10 - 39

Esta configuración dice que cualquier clase de User que implementePasswordAuthenticatedUserInterface - lo que nuestra clase, por supuesto, hace - utilizará el algoritmo auto donde Symfony elige el último y mejor algoritmo automáticamente.

El servicio de aseado de contraseñas

Gracias a esta configuración, tenemos acceso a un servicio "hasher" que es capaz de convertir una contraseña de texto plano en una versión hash utilizando este algoritmo auto. De vuelta aUserFactory, podemos utilizarlo para establecer la propiedad password:

60 lines | src/Factory/UserFactory.php
// ... lines 1 - 28
final class UserFactory extends ModelFactory
{
// ... lines 31 - 37
protected function getDefaults(): array
{
return [
// ... lines 41 - 42
'plainPassword' => 'tada',
];
}
// ... lines 46 - 58
}

En el constructor, añade un nuevo argumento: UserPasswordHasherInterface $passwordHasher. Yo le doy a Alt+Enter y voy a "Inicializar propiedades" para crear esa propiedad y establecerla:

69 lines | src/Factory/UserFactory.php
// ... lines 1 - 6
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
// ... lines 8 - 29
final class UserFactory extends ModelFactory
{
private UserPasswordHasherInterface $passwordHasher;
public function __construct(UserPasswordHasherInterface $passwordHasher)
{
parent::__construct();
$this->passwordHasher = $passwordHasher;
}
// ... lines 40 - 67
}

A continuación, podemos establecer password a $this->passwordHasher->hashPassword() y luego pasarle alguna cadena de texto plano.

Bueno... para ser sincero... aunque espero que esto tenga sentido a alto nivel... esto no funcionará del todo porque el primer argumento de hashPassword() es el objeto User... que aún no tenemos dentro de getDefaults().

No pasa nada porque, de todas formas, me gusta crear una propiedad plainPassword en User para facilitar todo esto. Añadamos eso a continuación, terminemos las fijaciones y actualicemos nuestro autentificador para validar la contraseña. Ah, pero no te preocupes: esa nueva propiedadplainPassword no se almacenará en la base de datos.