重定向到页面时，会话过期

Question

In my application, once a user logs in, taken to the home page where he can view his details. There is a button "Edit Profile" where the user will be taken to a page where he can edit the data. Once the editing successes, he is redirected back to the home page. But here, it is redirected to the login page. I think the session is expired unexpectedly. How to overcome this issue?

// This is my update info controller

/**
 * @Route("/update/{id}", name="update")
 * @param $id
 * @param Request $request
 * @param UserPasswordEncoderInterface $passwordEncoder
 * @param UserInterface $loggedUser
 * @return \Symfony\Component\HttpFoundation\RedirectResponse|Response
 */

public function updateUser($id,Request $request, UserPasswordEncoderInterface $passwordEncoder, UrlGeneratorInterface $urlGenerator){

    $loggedUser = $this->get('security.token_storage')->getToken()->getUser()->getId();

    if ($id == $loggedUser){
        $em = $this->getDoctrine()->getManager();
        $conn =$em->getConnection();
        $user = $em->find(User::class,$id);

        $form = $this->createForm(RegisterType::class,$user, [
            'validation_groups' => ['update'],
        ]);


        $form->handleRequest($request);

        if($form->isSubmitted() && $form->isValid()) {

            $file = $request->files->get('register')['image'];
            if($file){
                $fileName = md5(uniqid()).'.'.$file->guessExtension();
                $file->move(
                    $this->getParameter('uploads_dir'), $fileName
                );
                $user->setImage($fileName);
            }

            if($user->getPassword() !="") {
                $user->setPassword($passwordEncoder->encodePassword($user,$user->getPassword()));

                $sql = '
                    UPDATE user
                    SET first_name = :firstName, last_name = :lastName, id_number = :idNumber, phone_number = :phoneNumber, address = :address, password = :password
                    WHERE id= :id
    ';
                $stmt = $conn->prepare($sql);
                $stmt->execute(['firstName' => $user->getFirstName(),
                    'lastName' => $user->getLastName(),
                    'idNumber' => $user->getIdNumber(),
                    'phoneNumber' => $user->getPhoneNumber(),
                    'address' => $user->getAddress(),
                    'password' => $user->getPassword(),
                    'id' => $id]);
            } else {
                $sql = '
                    UPDATE user
                    SET first_name = :firstName, last_name = :lastName, id_number = :idNumber, phone_number = :phoneNumber, address = :address
                    WHERE id= :id
    ';
                $stmt = $conn->prepare($sql);
                $stmt->execute(['firstName' => $user->getFirstName(),
                    'lastName' => $user->getLastName(),
                    'idNumber' => $user->getIdNumber(),
                    'phoneNumber' => $user->getPhoneNumber(),
                    'address' => $user->getAddress(),
                    'id' => $id]);
            }



            return new RedirectResponse($urlGenerator->generate('home'));
        }
    } else {
        return new RedirectResponse($urlGenerator->generate('home'));
    }

    return $this->render('register/update.html.twig', [
        'form'=>$form->createView(),
    ]);
}

// This is RegisterType form

class RegisterType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('email',EmailType::class,[
                'label'=>'Email',
                'required' => false,
                'attr'=>['placeholder'=>"Email"]
            ])
            ->add('password',RepeatedType::class,[
                'type' => PasswordType::class,
                'invalid_message' => 'The password fields must match.',
                'required' => false,
                'options' => ['attr' => ['class' => 'password-field']],
                'first_options'  => ['label' => 'Password','attr'=>['placeholder'=>"Password"]],
                'second_options' => ['label' => 'Confirm Password','attr'=>['placeholder'=>"Confirm Password"]],
            ])
            ->add('firstName',TextType::class,['label'=>'First Name',  'attr'=>['placeholder'=>"First Name"]])
            ->add('lastName',TextType::class,['label'=>'Last Name','attr'=>['placeholder'=>"Last Name"]])
            ->add('address',TextareaType::class,['required' => false,'label'=>'Address','attr'=>['placeholder'=>"Address"]])
            ->add('idNumber',TextType::class,['label'=>'NIC Number','attr'=>['placeholder'=>"NIC Number"]])
            ->add('phoneNumber',TelType::class,['label'=>'Phone Number','attr'=>['placeholder'=>"Phone Number"]])
            ->add('image',FileType::class,['label'=>'Photo','required'=>false,'attr'=>['hidden'=>"hidden", 'accept'=>"image/jpeg, image/png"]])
            ->add('save',SubmitType::class,[
                'label'=>'Register',
                'attr' => [
                    'class'=>"btn btn-outline-success float-right"
                ]
            ])

        ;
    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => User::class,
        ]);
    }
}

// This is my User Class

class User implements UserInterface{

/**
 * @ORM\Id()
 * @ORM\GeneratedValue()
 * @ORM\Column(type="integer")
 */
private $id;

/**
     * @ORM\Column(type="string", length=180, unique=true)
 * @Assert\Email()
 * @Assert\NotBlank()
 */
private $email;

/**
 * @ORM\Column(type="json")
 */
private $roles = [];

/**
 * @var string The hashed password
 * @ORM\Column(type="string")
 * @Assert\NotBlank()
 */
private $password;

/**
 * @ORM\Column(type="string",length=255)
 * @Assert\NotBlank(groups={"update"})
 *
 */
private $firstName;

/**
 * @ORM\Column(type="string",length=255)
 * @Assert\NotBlank(groups={"update"})
 */
private $lastName;

/**
 * @ORM\Column(type="string",length=255,nullable=true)
 *
 */
private $image;

/**
 * @ORM\Column(type="string", nullable=true)
 */
private $address;

/**
 * @ORM\Column(type="string",length=10)
 * @Assert\Length("10",groups={"update"})
 */
private $phoneNumber;

/**
 * @ORM\Column(type="string",length=10)
 * @Assert\NotBlank(groups={"update"})
 * @Assert\Length("10",groups={"update"})
 */
private $idNumber;

/**
 * @ORM\OneToMany(targetEntity="App\Entity\Vehicle", mappedBy="user")
 */
private $vehicle;

/**
 * @ORM\OneToOne(targetEntity="App\Entity\Account", inversedBy="user")
 */
private $account;


public function __construct()
{
    $this->vehicle = new ArrayCollection();
}

public function getId(): ?int
{
    return $this->id;
}

public function getEmail()
{
    return $this->email;
}

public function setEmail( $email): self
{
    $this->email = $email;

    return $this;
}

/**
 * A visual identifier that represents this user.
 *
 * @see UserInterface
 */
public function getUsername()
{
    return (string) $this->email;
}

public function getRoles(): ?array
{
    return $this->roles;
}

public function setRoles(array $roles): self
{
    $this->roles = $roles;

    return $this;
}

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

public function setPassword($password): self
{
    $this->password = $password;

    return $this;
}

/**
 * @see UserInterface
 */
public function getSalt()
{
    // not needed when using the "bcrypt" algorithm in security.yaml
}

/**
 * @see UserInterface
 */
public function eraseCredentials()
{
    // If you store any temporary, sensitive data on the user, clear it here
    // $this->plainPassword = null;
}

public function getFirstName()
{
    return $this->firstName;
}

public function setFirstName( $firstName): self
{
    $this->firstName = $firstName;

    return $this;
}

public function getLastName()
{
    return $this->lastName;
}

public function setLastName( $lastName): self
{
    $this->lastName = $lastName;

    return $this;
}

public function getImage(): ?string
{
    return $this->image;
}

public function setImage(string $image): self
{
    $this->image = $image;

    return $this;
}

public function getAddress()
{
    return $this->address;
}

public function setAddress( $address): self
{
    $this->address = $address;

    return $this;
}

public function getIdNumber()
{
    return $this->idNumber;
}

public function setIdNumber( $idNumber): self
{
    $this->idNumber = $idNumber;

    return $this;
}

public function getPhoneNumber()
{
    return $this->phoneNumber;
}

public function setPhoneNumber( $phoneNumber): self
{
    $this->phoneNumber = $phoneNumber;

    return $this;
}

/**
 * @return Collection|Vehicle[]
 */
public function getVehicle(): Collection
{
    return $this->vehicle;
}

public function addVehicle(Vehicle $vehicle): self
{
    if (!$this->vehicle->contains($vehicle)) {
        $this->vehicle[] = $vehicle;
        $vehicle->setUser($this);
    }

    return $this;
}

public function removeVehicle(Vehicle $vehicle): self
{
    if ($this->vehicle->contains($vehicle)) {
        $this->vehicle->removeElement($vehicle);
        // set the owning side to null (unless already changed)
        if ($vehicle->getUser() === $this) {
            $vehicle->setUser(null);
        }
    }

    return $this;
}

public function getAccount(): ?Account
{
    return $this->account;
}

public function setAccount(?Account $account): self
{
    $this->account = $account;

    return $this;
}

}

Answer 1

Assuming you are using the default voter and entity security user provider.

This should apply for Symfony 3.4+, but knowing which version of Symfony you are using, would grant other approaches.

At the end of every request (unless your firewall is stateless), your User object is serialized to the session. At the beginning of the next request, it's deserialized and then passed to your user provider to "refresh" it (eg Doctrine queries for a fresh user).

Then, the two User objects (the original from the session and the refreshed User object) are "compared" to see if they are "equal". By default, the core AbstractToken class compares the return values of the getPassword(), getSalt() and getUsername() methods. If any of these are different, your user will be logged out. This is a security measure to make sure that malicious users can be de-authenticated if core user data changes.

However, in some cases, this process can cause unexpected authentication problems. If you're having problems authenticating, it could be that you are authenticating successfully, but you immediately lose authentication after the first redirect.

Source: https://symfony.com/doc/current/security/user_provider.html#understanding-how-users-are-refreshed-from-the-session

The issue appears to be caused by

$user->setPassword($passwordEncoder->encodePassword($user,$user->getPassword()));

Which will generate a new hashed password from the submitted password, invalidating the user state, even if it is identical.

You would need to store the user's plain-text password, and validate if it has changed, and apply the password changes only if it changed.

Additionally your image form setting is not valid, since your User::$image requires a string, but the form will upload a File object (causing an invalid Entity state or calling File::__toString and changing the image). You should use a separate property for the image upload and manually draw the current image in your view or consider using a data transformer in your Form rather than in your controller to handle the state change. See: https://symfony.com/doc/current/form/data_transformers.html

Replace your current password and image form fields with the plainPassword and uploadImage fields.

class RegisterType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            //...
            ->add('plainPassword',RepeatedType::class,[
                'type' => PasswordType::class,
                'invalid_message' => 'The password fields must match.',
                'required' => false,
                'options' => ['attr' => ['class' => 'password-field']],
                'first_options'  => ['label' => 'Password','attr'=>['placeholder'=>"Password"]],
                'second_options' => ['label' => 'Confirm Password','attr'=>['placeholder'=>"Confirm Password"]],
            ])
            ->add('uploadImage',FileType::class,['label'=>'Photo','required'=>false,'attr'=>['hidden'=>"hidden", 'accept'=>"image/jpeg, image/png"]]);
      //...
}

You should also seriously consider using a DTO , instead of the direct User entity from Doctrine to manage your data, to prevent an invalid entity state.

Then create the properties and getter/setter methods in you User entity, to store the form values.

class User implements UserInterface
{
      /**
       * @var string
       */
      private $plainPassword = '';

      /**
       * @var File|null
       */
      private $uploadImage;


      public function getPlainPassword(): string
      {
          return $this->plainPassword;
      }

      public function setPlainPassword(string $plainPassword): void
      {
          $this->plainPassword = $plainPassword;
      }

      /**
       * @see UserInterface
       */
      public function eraseCredentials()
      {
          $this->plainPassword = null;
      }

      public function getUploadImage(): ?File
      {
          return $this->uploadImage;
      }

      public function setUploadImage(?File $file): void
      {
          $this->uploadImage = $file;
      }

      //...
}

Since you're using the Entity manager and the RegisterType field, you can remove the manual update queries. Since the $form->handleRequest() will be applying the changes directly to the User object. I also suggest using the Paramconverter to benefit from the entity Dependency Injection for the User object.

/**
 * @Route("/{user}/update", name="update", requirements={ "user":"\d+" }, methods={"GET","POST"})
 * @param User $user
 * @param Request $request
 * @param UserPasswordEncoderInterface $passwordEncoder
 * @param UserInterface $loggedUser
 * @return Response
 */
public function updateUser(User $user, Request $request, UserPasswordEncoderInterface $passwordEncoder, UrlGeneratorInterface $urlGenerator): Response
{    
     $loggedinUser = $this->getUser(); //helper from ControllerTrait
     if ($loggedinUser && loggedinUser->getId() === $user->getId()) {
         $form = $this->createForm(RegisterType::class,$user, [
            'validation_groups' => ['update'],
         ]);
         $currentImage = $user->getImage();
         $form->handleRequest($request);
         if ($form->isSubmitted() && $form->isValid()) {
             if ($file = $user->getUploadImage()) {
                 //this logic should be moved to the Form using a data transformer
                 $fileName = md5(uniqid()).'.'.$file->guessExtension();
                 $file->move(
                     $this->getParameter('uploads_dir'), $fileName
                 );
                 $user->setImage($fileName);
             }
             if ('' !== $user->getPlainPassword() && !$passwordEncoder->isPasswordValid($user->getPassword(), $user->getPlainPassword())) {
                 //change password only when changed
                 $user->setPassword($passwordEncoder->encodePassword($user, $user->getPlainPassword()));
                 $user->eraseCredentials();
             }
             $em = $this->getDoctrine()->getManager();
             $em->flush();

             return new RedirectResponse($urlGenerator->generate('home'));
         }

         return $this->render('register/update.html.twig', [
              'form'=>$form->createView(),
        ]);
    }

    return new RedirectResponse($urlGenerator->generate('home'));
}

---

If you are using Symfony < 4.1, you will need to implement \\Serializable and add the serialize and unserialize methods to your User class, otherwise your entire User object will be serialized and invalidated on any change.

class User implements UserInterface, \Serializable
{
   //... 

    /** @see \Serializable::serialize() */
    public function serialize()
    {
        return serialize(array(
            $this->id,
            $this->username,
            $this->password,
            //$this->roles //(optional)
        ));
    }

    /** @see \Serializable::unserialize() */
    public function unserialize($serialized)
    {
        list (
            $this->id,
            $this->username,
            $this->password,
            //$this->roles //(optional)
        ) = unserialize($serialized, array('allowed_classes' => false));
    }
}

Answer 2

Use a temporary field to hold the plaintext password in the form pre-encoding/pre-hashing (see: https://symfony.com/doc/4.0/doctrine/registration_form.html#registration-password-max - field is called plainPassword or similar).

I suspect that there is some unexpected behaviour when setting an empty password, which might invalidate session cache (symfony stores some user data to determine, if the user must be reloaded from database, and if relevant data changed, user might be logged out). The redirection alone should definitely not logout a user.

Hopefully, this will be enough.