symfony 4 - encoder zapisuje hasło bez soli

Odpowiedz Nowy wątek
2018-09-24 21:45

Rejestracja: 3 lata temu

Ostatnio: 4 minuty temu

0

Cześć,
Mam mega dziwny problem, może Wy znajdziecie przyczynę.
Przeniosłem aplikację z jednego serwera na drugi (przez git'a). Używam w niej lexit/jwt, jako encoder bcrypt
Mam komendę do generowania kont userów:

<?php

namespace App\Command;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use App\Entity\User;
use App\Entity\UserCredensials;
use App\Repository\UserRepository;
use App\Utils\Validator;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
use Symfony\Component\Console\Exception\RuntimeException;

class UserCreateCommand extends Command
{
    protected static $defaultName = 'app:user:create';

    private $entityManager;
    private $passwordEncoder;
    private $validator;
    private $users;

    public function __construct(EntityManagerInterface $entityManager, UserPasswordEncoderInterface $encoder, Validator $validator, UserRepository $users)
    {
        parent::__construct();
        $this->entityManager = $entityManager;
        $this->passwordEncoder = $encoder;
        $this->validator = $validator;
        $this->users = $users;
        $this->userPlainPassword = bin2hex(random_bytes(random_int(12, 16)));
        $this->userSalt = bin2hex(random_bytes(32));
    }

    protected function configure()
    {
        $this
            ->setDescription('Command to generate user')
            ->addArgument('email', InputArgument::REQUIRED, 'User email')
            ->addArgument('name', InputArgument::REQUIRED, 'User name')
            ->addArgument('surname', InputArgument::REQUIRED, 'User surname')
        ;
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $user = new User();

        $this->validateUserData($input->getArgument('email'));

        $user->setEmail($input->getArgument('email'));
        $user->setName($input->getArgument('name'));
        $user->setSurname($input->getArgument('surname'));
        $user->setCreatedAt(new \DateTime());

        $this->entityManager->persist($user);
        $this->entityManager->flush();

        $userCredensials = new UserCredensials();

        $userCredensials->setEmail($input->getArgument('email'));
        $userCredensials->setUser($user);
        $userCredensials->setSalt($this->userSalt);
        $userCredensials->setPassword($this->passwordEncoder->encodePassword($userCredensials, $this->userPlainPassword));
        $userCredensials->setActive(true);

        $this->entityManager->persist($userCredensials);
        $this->entityManager->flush();

        $output->writeLn('User has been created');
        $output->writeLn('User password is: ' . $this->userPlainPassword);
    }

    private function validateUserData(String $email)
    {
        $existingUser = $this->users->findOneBy(['email' => $email]);
        if (null !== $existingUser) {
            throw new RuntimeException(sprintf('There is already a user registered with the "%s" email.', $email));
        }
        $this->validator->validateEmail($email);
    }
}

Na poprzednim serwerze wszystko ładnie działało. Niestety po przeniesieniu utworzone hasło jest niezgodne. Sprawdziłem hash hasła i odkryłem że hash jest tylko samego hasła, bez soli, natomiast sprawdzanie go już sól dodaje. Widzicie jakiś błąd? Wersja php'a to 7.2. Poniżej wrzucam jeszcze klasę UserCredensials, oraz configi:

<?php

namespace App\Entity;
use Symfony\Component\Security\Core\User\UserInterface;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass="App\Repository\UserCredensialsRepository")
 */
class UserCredensials implements UserInterface
{
    /**
     * @ORM\Id()
     * @ORM\GeneratedValue()
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\Column(type="string", length=150)
     */
    private $email;

    /**
     * @ORM\Column(type="string", length=64)
     */
    private $password;

    /**
     * @ORM\Column(type="string", length=32)
     */
    private $salt;

    /**
     * @ORM\OneToOne(targetEntity="App\Entity\User", cascade={"persist", "remove"})
     * @ORM\JoinColumn(nullable=false)
     */
    private $user;

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

    /**
     * @ORM\Column(type="boolean")
     */
    private $active;

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

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

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

        return $this;
    }

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

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

        return $this;
    }

    public function getSalt(): ?string
    {
        return $this->salt;
    }

    public function setSalt(string $salt): self
    {
        $this->salt = $salt;

        return $this;
    }

    public function getUser(): ?User
    {
        return $this->user;
    }

    public function setUser(User $user): self
    {
        $this->user = $user;

        return $this;
    }

    public function getPasswordUpdatedAt(): ?\DateTimeInterface
    {
        return $this->passwordUpdatedAt;
    }

    public function setPasswordUpdatedAt(?\DateTimeInterface $passwordUpdatedAt): self
    {
        $this->passwordUpdatedAt = $passwordUpdatedAt;

        return $this;
    }

    public function getActive(): ?bool
    {
        return $this->active;
    }

    public function setActive(bool $active): self
    {
        $this->active = $active;

        return $this;
    }

    public function getRoles()
    {
        return ['ROLE_USER'];
    }

    public function getUsername(): string
    {
        return $this->email;
    }

    public function eraseCredentials()
    {
        //pass
    }
}
lexik_jwt_authentication:
    secret_key: '%env(resolve:JWT_SECRET_KEY)%'
    public_key: '%env(resolve:JWT_PUBLIC_KEY)%'
    pass_phrase: '%env(JWT_PASSPHRASE)%'
security:
    encoders:
        App\Entity\UserCredensials: bcrypt

    providers:
        database_users:
            entity: { class: App\Entity\UserCredensials, property: email }

    firewalls:

        login:
            pattern: ^/api/login
            stateless: true
            anonymous: true
            json_login:
                check_path: /api/login
                success_handler: lexik_jwt_authentication.handler.authentication_success
                failure_handler: lexik_jwt_authentication.handler.authentication_failure

        api:
            pattern:   ^/api
            stateless: true
            guard:
                authenticators:
                    - lexik_jwt_authentication.jwt_token_authenticator

    access_control:
        - { path: ^/api/login, roles: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/api,       roles: IS_AUTHENTICATED_FULLY }
acl:
    connection: default
Na marginesie: rzuć okiem do słownika na poprawny zapis słowa credentials. - Patryk27 2018-09-24 22:14

Pozostało 580 znaków

2018-09-24 23:16

Rejestracja: 3 lata temu

Ostatnio: 4 minuty temu

0

Problem został połowicznie rozwiązany. Przepięcie portu z 80 na 8080 rozwiązało problem.

Pozostało 580 znaków

Odpowiedz

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0